Files changed (1) hide show
  1. file.txt +8149 -3068
file.txt CHANGED
@@ -1,147 +1,877 @@
 
 
1
- import type {EventSubscription as EventSubscription_2} from 'react-native/Libraries/vendor/emitter/EventEmitter';
2
- import type {ListRenderItem} from '@react-native/virtualized-lists';
3
- import type {ListRenderItemInfo} from '@react-native/virtualized-lists';
4
- import * as React_2 from 'react';
 
 
5
- import type {ViewabilityConfig} from '@react-native/virtualized-lists';
6
- import type {ViewToken} from '@react-native/virtualized-lists';
 
7
  import {VirtualizedListProps} from '@react-native/virtualized-lists';
 
8
- import type {VirtualizedListWithoutRenderItemProps} from '@react-native/virtualized-lists';
9
 
10
- export declare type AccessibilityActionEvent = NativeSyntheticEvent<
11
  Readonly<{
12
  actionName: string;
13
  }>
14
  >;
 
15
- export declare type AccessibilityActionInfo = Readonly<{
16
  name: AccessibilityActionName | string;
17
- label?: string | undefined;
18
  }>;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
19
- export declare type AccessibilityActionName =
20
  | 'activate'
21
  | 'increment'
22
  | 'decrement'
23
  | 'longpress'
24
  | 'magicTap'
25
  | 'escape';
 
26
- export declare type AccessibilityAnnouncementEventName = 'announcementFinished';
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
27
- export declare type AccessibilityAnnouncementFinishedEvent = {
28
- announcement: string;
29
- success: boolean;
30
  };
31
- export declare type AccessibilityAnnouncementFinishedEventHandler = (
32
- event: AccessibilityAnnouncementFinishedEvent
33
- ) => void;
34
- export declare type AccessibilityChangeEvent = boolean;
35
- export declare type AccessibilityChangeEventHandler = (
36
- event: AccessibilityChangeEvent
 
 
37
- ) => void;
38
- export declare type AccessibilityChangeEventName =
39
- | 'change' // deprecated, maps to screenReaderChanged
 
40
- | 'boldTextChanged' // iOS-only Event
41
- | 'grayscaleChanged' // iOS-only Event
42
- | 'invertColorsChanged' // iOS-only Event
43
- | 'reduceMotionChanged'
44
- | 'highTextContrastChanged' // Android-only Event
45
- | 'darkerSystemColorsChanged' // iOS-only Event
46
- | 'screenReaderChanged'
47
- | 'reduceTransparencyChanged';
48
- export declare type AccessibilityEventTypes =
49
- | 'click'
50
- | 'focus'
51
- | 'viewHoverEnter';
 
 
 
 
52
- export declare const AccessibilityInfo: AccessibilityInfoStatic;
 
53
- export declare type AccessibilityInfo = AccessibilityInfoStatic;
 
54
- export declare interface AccessibilityInfoStatic {
55
- isBoldTextEnabled: () => Promise<boolean>;
 
56
- isGrayscaleEnabled: () => Promise<boolean>;
 
57
- isInvertColorsEnabled: () => Promise<boolean>;
 
58
- isReduceMotionEnabled: () => Promise<boolean>;
 
59
- isHighTextContrastEnabled: () => Promise<boolean>;
 
60
- isDarkerSystemColorsEnabled: () => Promise<boolean>;
 
61
  prefersCrossFadeTransitions(): Promise<boolean>;
 
62
- isReduceTransparencyEnabled: () => Promise<boolean>;
 
63
- isScreenReaderEnabled: () => Promise<boolean>;
 
64
  isAccessibilityServiceEnabled(): Promise<boolean>;
 
 
65
- addEventListener(
66
- eventName: AccessibilityChangeEventName,
67
- handler: AccessibilityChangeEventHandler
68
- ): EmitterSubscription;
69
- addEventListener(
70
- eventName: AccessibilityAnnouncementEventName,
71
- handler: AccessibilityAnnouncementFinishedEventHandler
72
- ): EmitterSubscription;
73
- setAccessibilityFocus: (reactTag: number) => void;
 
 
 
 
 
 
74
- announceForAccessibility: (announcement: string) => void;
 
75
  announceForAccessibilityWithOptions(
76
  announcement: string,
 
77
- options: {queue?: boolean | undefined}
 
78
  ): void;
79
- getRecommendedTimeoutMillis: (originalTimeout: number) => Promise<number>;
80
- sendAccessibilityEvent: (
81
- handle: HostInstance,
82
- eventType: AccessibilityEventTypes
83
- ) => void;
84
- }
85
- export declare type AccessibilityProperties = AccessibilityProps;
86
- export declare type AccessibilityPropertiesAndroid = AccessibilityPropsAndroid;
87
- export declare type AccessibilityPropertiesIOS = AccessibilityPropsIOS;
88
- export declare interface AccessibilityProps
89
- extends AccessibilityPropsAndroid,
90
- AccessibilityPropsIOS {
91
- accessible?: boolean | undefined;
92
- accessibilityActions?: ReadonlyArray<AccessibilityActionInfo> | undefined;
93
- accessibilityLabel?: string | undefined;
94
- 'aria-label'?: string | undefined;
95
- accessibilityRole?: AccessibilityRole | undefined;
96
- accessibilityState?: AccessibilityState | undefined;
97
- 'aria-busy'?: boolean | undefined;
98
- 'aria-checked'?: boolean | 'mixed' | undefined;
99
- 'aria-disabled'?: boolean | undefined;
100
- 'aria-expanded'?: boolean | undefined;
101
- 'aria-selected'?: boolean | undefined;
102
- accessibilityHint?: string | undefined;
103
- accessibilityValue?: AccessibilityValue | undefined;
104
- 'aria-valuemax'?: AccessibilityValue['max'] | undefined;
105
- 'aria-valuemin'?: AccessibilityValue['min'] | undefined;
106
- 'aria-valuenow'?: AccessibilityValue['now'] | undefined;
107
- 'aria-valuetext'?: AccessibilityValue['text'] | undefined;
108
- onAccessibilityAction?:
109
- | ((event: AccessibilityActionEvent) => void)
110
- | undefined;
111
- importantForAccessibility?:
112
- | ('auto' | 'yes' | 'no' | 'no-hide-descendants')
113
- | undefined;
114
- 'aria-hidden'?: boolean | undefined;
115
- 'aria-modal'?: boolean | undefined;
116
- role?: Role | undefined;
117
- }
118
- export declare interface AccessibilityPropsAndroid {
119
- accessibilityLabelledBy?: string | string[] | undefined;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
120
  'aria-labelledby'?: string | undefined;
 
121
- accessibilityLiveRegion?: 'none' | 'polite' | 'assertive' | undefined;
 
122
  'aria-live'?: ('polite' | 'assertive' | 'off') | undefined;
 
123
  importantForAccessibility?:
124
- | 'auto'
125
- | 'yes'
126
- | 'no'
127
- | 'no-hide-descendants'
128
  | undefined;
129
- }
 
130
- export declare interface AccessibilityPropsIOS {
131
- accessibilityElementsHidden?: boolean | undefined;
132
- accessibilityViewIsModal?: boolean | undefined;
133
- onAccessibilityEscape?: (() => void) | undefined;
134
- onAccessibilityTap?: (() => void) | undefined;
135
- onMagicTap?: (() => void) | undefined;
136
  accessibilityIgnoresInvertColors?: boolean | undefined;
 
137
- accessibilityLanguage?: string | undefined;
 
138
  accessibilityShowsLargeContentViewer?: boolean | undefined;
 
139
  accessibilityLargeContentTitle?: string | undefined;
 
 
 
 
 
 
140
- }
 
141
- export declare type AccessibilityRole =
142
  | 'none'
143
  | 'button'
 
144
  | 'togglebutton'
145
  | 'link'
146
  | 'search'
147
  | 'image'
@@ -167,614 +897,1048 @@
167
  | 'tabbar'
168
  | 'tablist'
169
  | 'timer'
170
  | 'list'
171
- | 'toolbar';
 
 
 
 
 
 
 
 
 
 
 
172
- export declare interface AccessibilityState {
173
  disabled?: boolean | undefined;
 
174
  selected?: boolean | undefined;
 
175
- checked?: boolean | 'mixed' | undefined;
 
176
  busy?: boolean | undefined;
 
177
  expanded?: boolean | undefined;
178
- }
 
179
- export declare interface AccessibilityValue {
180
- min?: number | undefined;
 
181
- max?: number | undefined;
 
182
- now?: number | undefined;
 
183
- text?: string | undefined;
184
- }
 
185
- export declare const ActionSheetIOS: ActionSheetIOSStatic;
 
186
- export declare type ActionSheetIOS = ActionSheetIOSStatic;
187
- export declare interface ActionSheetIOSOptions {
188
- title?: string | undefined;
189
- options: string[];
190
- cancelButtonIndex?: number | undefined;
191
- destructiveButtonIndex?: number | number[] | undefined | null;
192
- message?: string | undefined;
193
- anchor?: number | undefined;
194
- tintColor?: ColorValue | ProcessedColorValue | undefined;
195
- cancelButtonTintColor?: ColorValue | ProcessedColorValue | undefined;
196
- disabledButtonTintColor?: ColorValue | ProcessedColorValue | undefined;
197
- userInterfaceStyle?: 'light' | 'dark' | undefined;
198
- disabledButtonIndices?: number[] | undefined;
199
- }
200
- export declare interface ActionSheetIOSStatic {
201
- showActionSheetWithOptions: (
202
  options: ActionSheetIOSOptions,
203
  callback: (buttonIndex: number) => void
204
- ) => void;
 
205
- showShareActionSheetWithOptions: (
206
  options: ShareActionSheetIOSOptions,
207
- failureCallback: (error: Error) => void,
 
 
208
- successCallback: (success: boolean, method: string) => void
209
- ) => void;
 
210
  dismissActionSheet: () => void;
211
- }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
212
- export declare class ActivityIndicator extends ActivityIndicatorBase {}
213
- export declare const ActivityIndicatorBase: Constructor<NativeMethods> &
214
- typeof ActivityIndicatorComponent;
215
- export declare class ActivityIndicatorComponent extends React_2.Component<ActivityIndicatorProps> {}
216
- export declare type ActivityIndicatorIOSProperties = ActivityIndicatorIOSProps;
 
217
- export declare interface ActivityIndicatorIOSProps extends ViewProps {
218
- animating?: boolean | undefined;
219
- color?: ColorValue | undefined;
220
  hidesWhenStopped?: boolean | undefined;
 
 
221
- onLayout?: ((event: LayoutChangeEvent) => void) | undefined;
 
 
 
 
 
222
- size?: 'small' | 'large' | undefined;
 
 
 
223
- style?: StyleProp<ViewStyle> | undefined;
224
- }
 
225
- export declare type ActivityIndicatorProperties = ActivityIndicatorProps;
 
226
- export declare interface ActivityIndicatorProps extends ViewProps {
 
227
- animating?: boolean | undefined;
 
228
- color?: ColorValue | undefined;
 
229
- hidesWhenStopped?: boolean | undefined;
230
- size?: number | 'small' | 'large' | undefined;
231
- style?: StyleProp<ViewStyle> | undefined;
232
- }
233
- export declare const Alert: AlertStatic;
234
- export declare type Alert = AlertStatic;
235
- export declare interface AlertButton {
236
- text?: string | undefined;
237
- onPress?:
238
- | ((value?: string) => void)
239
- | ((value?: {login: string; password: string}) => void)
240
- | undefined;
241
- isPreferred?: boolean | undefined;
 
 
 
242
- style?: 'default' | 'cancel' | 'destructive' | undefined;
243
- }
 
 
244
- export declare interface AlertOptions {
 
245
- cancelable?: boolean | undefined;
246
- userInterfaceStyle?: 'unspecified' | 'light' | 'dark' | undefined;
247
- onDismiss?: (() => void) | undefined;
248
- }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
249
- export declare interface AlertStatic {
250
- alert: (
251
- title: string,
252
- message?: string,
253
- buttons?: AlertButton[],
254
  options?: AlertOptions
255
- ) => void;
256
- prompt: (
257
- title: string,
258
- message?: string,
 
 
 
259
- callbackOrButtons?: ((text: string) => void) | AlertButton[],
260
- type?: AlertType,
261
  defaultValue?: string,
262
  keyboardType?: string,
263
  options?: AlertOptions
264
- ) => void;
265
  }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
266
  export declare type AlertType =
267
  | 'default'
268
  | 'plain-text'
269
  | 'secure-text'
270
  | 'login-password';
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
271
- export declare type AnimatableNumericValue = number | Animated.AnimatedNode;
272
- export declare type AnimatableStringValue = string | Animated.AnimatedNode;
273
- export declare namespace Animated {
274
- export type AnimatedValue = Value;
275
- export type AnimatedValueXY = ValueXY;
276
- export class Animated {}
277
- export class AnimatedNode {
278
- addListener(callback: (value: any) => any): string;
279
- removeListener(id: string): void;
280
- removeAllListeners(): void;
281
- hasListeners(): boolean;
 
 
 
 
 
 
 
282
  }
283
- export class AnimatedWithChildren extends AnimatedNode {}
 
284
- export type RgbaValue = {
 
 
 
 
 
 
285
- readonly r: number;
 
 
 
 
286
- readonly g: number;
 
 
 
 
287
- readonly b: number;
 
288
- readonly a: number;
 
289
  };
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
290
- export type RgbaAnimatedValue = {
 
 
 
 
 
 
 
 
 
 
 
291
- readonly r: AnimatedValue;
292
- readonly g: AnimatedValue;
 
293
- readonly b: AnimatedValue;
294
- readonly a: AnimatedValue;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
295
  };
296
- export type AnimatedConfig = {
297
- readonly useNativeDriver: boolean;
298
- };
299
- export class AnimatedColor extends AnimatedWithChildren {
300
- r: AnimatedValue;
301
- g: AnimatedValue;
302
- b: AnimatedValue;
303
- a: AnimatedValue;
304
- constructor(
305
- valueIn?: RgbaValue | RgbaAnimatedValue | ColorValue | null,
306
- config?: AnimatedConfig | null
307
- );
308
- nativeColor: unknown; // Unsure what to do here
309
- setValue: (value: RgbaValue | ColorValue) => void;
310
- setOffset: (offset: RgbaValue) => void;
311
- flattenOffset: () => void;
312
- extractOffset: () => void;
313
- addListener: (callback: (value: ColorValue) => unknown) => string;
314
- removeListener: (id: string) => void;
315
- removeAllListeners: () => void;
316
- stopAnimation: (callback: (value: ColorValue) => unknown) => void;
317
- resetAnimation: (callback: (value: ColorValue) => unknown) => void;
318
- }
319
- export class AnimatedInterpolation<
320
- OutputT extends number | string,
321
- > extends AnimatedWithChildren {
322
- interpolate(
323
- config: InterpolationConfigType
324
- ): AnimatedInterpolation<OutputT>;
325
- }
326
- export type ExtrapolateType = 'extend' | 'identity' | 'clamp';
327
- export type InterpolationConfigType = {
328
- inputRange: number[];
329
- outputRange: number[] | string[];
330
- easing?: ((input: number) => number) | undefined;
331
- extrapolate?: ExtrapolateType | undefined;
332
- extrapolateLeft?: ExtrapolateType | undefined;
333
- extrapolateRight?: ExtrapolateType | undefined;
334
- };
335
- export type ValueListenerCallback = (state: {value: number}) => void;
336
- export type Animation = {
337
- start(
338
- fromValue: number,
339
- onUpdate: (value: number) => void,
340
- onEnd: EndCallback | null,
341
- previousAnimation: Animation | null,
342
- animatedValue: AnimatedValue
343
- ): void;
344
- stop(): void;
345
- };
346
- export class Value extends AnimatedWithChildren {
347
- constructor(value: number, config?: AnimatedConfig | null);
348
- setValue(value: number): void;
349
- setOffset(offset: number): void;
350
- flattenOffset(): void;
351
- extractOffset(): void;
352
- addListener(callback: ValueListenerCallback): string;
353
- removeListener(id: string): void;
354
- removeAllListeners(): void;
355
- stopAnimation(callback?: (value: number) => void): void;
356
- resetAnimation(callback?: (value: number) => void): void;
357
- interpolate<OutputT extends number | string>(
358
- config: InterpolationConfigType
359
- ): AnimatedInterpolation<OutputT>;
360
- animate(animation: Animation, callback?: EndCallback | null): void;
361
- }
362
- export type ValueXYListenerCallback = (value: {x: number; y: number}) => void;
363
- export class ValueXY extends AnimatedWithChildren {
364
- x: AnimatedValue;
365
- y: AnimatedValue;
366
- constructor(
367
- valueIn?: {x: number | AnimatedValue; y: number | AnimatedValue},
368
- config?: AnimatedConfig | null
369
- );
370
- setValue(value: {x: number; y: number}): void;
371
- setOffset(offset: {x: number; y: number}): void;
372
- flattenOffset(): void;
373
- extractOffset(): void;
374
- resetAnimation(callback?: (value: {x: number; y: number}) => void): void;
375
- stopAnimation(callback?: (value: {x: number; y: number}) => void): void;
376
- addListener(callback: ValueXYListenerCallback): string;
377
- removeListener(id: string): void;
378
- getLayout(): {[key: string]: AnimatedValue};
379
- getTranslateTransform(): [
380
- {translateX: AnimatedValue},
381
- {translateY: AnimatedValue},
382
- ];
383
- }
384
- export type EndResult = {finished: boolean};
385
- export type EndCallback = (result: EndResult) => void;
386
- export interface CompositeAnimation {
387
- start: (callback?: EndCallback) => void;
388
- stop: () => void;
389
- reset: () => void;
390
- }
391
- export interface AnimationConfig {
392
- isInteraction?: boolean | undefined;
393
  useNativeDriver: boolean;
394
  }
395
- export function decay(
396
- value: AnimatedValue | AnimatedValueXY,
397
- config: DecayAnimationConfig
398
- ): CompositeAnimation;
 
399
- export interface DecayAnimationConfig extends AnimationConfig {
 
400
- velocity: number | {x: number; y: number};
 
401
- deceleration?: number | undefined;
 
 
 
402
  }
403
- const timing: (
404
- value: AnimatedValue | AnimatedValueXY,
405
- config: TimingAnimationConfig
406
- ) => CompositeAnimation;
 
407
- export interface TimingAnimationConfig extends AnimationConfig {
408
- toValue:
409
- | number
410
- | AnimatedValue
411
- | {x: number; y: number}
412
- | AnimatedValueXY
413
- | AnimatedInterpolation<number>;
414
- easing?: ((value: number) => number) | undefined;
415
- duration?: number | undefined;
416
- delay?: number | undefined;
417
- }
418
- export interface SpringAnimationConfig extends AnimationConfig {
419
- toValue:
420
- | number
421
- | AnimatedValue
422
- | {x: number; y: number}
423
- | AnimatedValueXY
424
- | RgbaValue
425
- | AnimatedColor
426
- | AnimatedInterpolation<number>;
427
- overshootClamping?: boolean | undefined;
428
- restDisplacementThreshold?: number | undefined;
429
- restSpeedThreshold?: number | undefined;
430
- velocity?: number | {x: number; y: number} | undefined;
431
- bounciness?: number | undefined;
432
- speed?: number | undefined;
433
- tension?: number | undefined;
434
- friction?: number | undefined;
435
- stiffness?: number | undefined;
436
- mass?: number | undefined;
437
- damping?: number | undefined;
438
- delay?: number | undefined;
439
- }
440
- export interface LoopAnimationConfig {
441
- iterations?: number | undefined; // default -1 for infinite
442
- resetBeforeIteration?: boolean | undefined;
443
- }
444
- export function add<OutputT extends number | string>(
445
- a: Animated,
446
- b: Animated
447
- ): AnimatedAddition<OutputT>;
448
- export class AnimatedAddition<
449
- OutputT extends number | string,
450
- > extends AnimatedInterpolation<OutputT> {}
451
- export function subtract<OutputT extends number | string>(
452
- a: Animated,
453
- b: Animated
454
- ): AnimatedSubtraction<OutputT>;
455
- export class AnimatedSubtraction<
456
- OutputT extends number | string,
457
- > extends AnimatedInterpolation<OutputT> {}
458
- export function divide<OutputT extends number | string>(
459
- a: Animated,
460
- b: Animated
461
- ): AnimatedDivision<OutputT>;
462
- export class AnimatedDivision<
463
- OutputT extends number | string,
464
- > extends AnimatedInterpolation<OutputT> {}
465
- export function multiply<OutputT extends number | string>(
466
- a: Animated,
467
- b: Animated
468
- ): AnimatedMultiplication<OutputT>;
469
- export class AnimatedMultiplication<
470
- OutputT extends number | string,
471
- > extends AnimatedInterpolation<OutputT> {}
472
- export function modulo<OutputT extends number | string>(
473
- a: Animated,
474
- modulus: number
475
- ): AnimatedModulo<OutputT>;
476
- export class AnimatedModulo<
477
- OutputT extends number | string,
478
- > extends AnimatedInterpolation<OutputT> {}
479
- export function diffClamp<OutputT extends number | string>(
480
- a: Animated,
481
  min: number,
482
- max: number
483
- ): AnimatedDiffClamp<OutputT>;
484
- export class AnimatedDiffClamp<
485
- OutputT extends number | string,
486
- > extends AnimatedInterpolation<OutputT> {}
487
- export function delay(time: number): CompositeAnimation;
488
- export function sequence(
489
- animations: Array<CompositeAnimation>
490
- ): CompositeAnimation;
491
- export function stagger(
492
- time: number,
493
- animations: Array<CompositeAnimation>
494
- ): CompositeAnimation;
495
- export function loop(
496
- animation: CompositeAnimation,
497
- config?: LoopAnimationConfig
498
- ): CompositeAnimation;
499
- export function spring(
500
- value: AnimatedValue | AnimatedValueXY,
501
- config: SpringAnimationConfig
502
- ): CompositeAnimation;
503
- export type ParallelConfig = {
504
- stopTogether?: boolean | undefined; // If one is stopped, stop all. default: true
505
- };
506
- export function parallel(
507
- animations: Array<CompositeAnimation>,
508
- config?: ParallelConfig
509
- ): CompositeAnimation;
510
- export type Mapping = {[key: string]: Mapping} | AnimatedValue;
511
- export interface EventConfig<T> {
512
- listener?: ((event: NativeSyntheticEvent<T>) => void) | undefined;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
513
  useNativeDriver: boolean;
514
  }
515
- export function event<T>(
516
- argMapping: Array<Mapping | null>,
517
- config?: EventConfig<T>
518
- ): (...args: any[]) => void;
 
519
- export type ComponentProps<T> = T extends
520
- | React_2.ComponentType<infer P>
521
- | React_2.Component<infer P>
 
 
 
 
 
522
- ? P
523
- : never;
524
- export type LegacyRef<C> = {getNode(): C};
525
- export type Nullable = undefined | null;
 
 
 
 
526
- export type Primitive = string | number | boolean | symbol;
 
527
- export type Builtin = Function | Date | Error | RegExp;
528
- export interface WithAnimatedArray<P> extends Array<WithAnimatedValue<P>> {}
 
 
529
- export type WithAnimatedObject<T> = {
 
 
530
- [K in keyof T]: WithAnimatedValue<T[K]>;
531
  };
532
- export type WithAnimatedValue<T> = T extends Builtin | Nullable
533
- ? T
534
- : T extends Primitive
535
- ? T | Value | AnimatedInterpolation<number | string> // add `Value` and `AnimatedInterpolation` but also preserve original T
536
- : T extends Array<infer P>
537
- ? WithAnimatedArray<P>
538
- : T extends {}
539
- ? WithAnimatedObject<T>
540
- : T; // in case it's something we don't yet know about (for .e.g bigint)
541
- export type NonAnimatedProps = 'key' | 'ref';
542
- export type TAugmentRef<T> =
543
- T extends React_2.Ref<infer R>
544
- ? unknown extends R
545
- ? never
546
- : React_2.Ref<R | LegacyRef<R>>
547
- : never;
548
- export type AnimatedProps<T> = {
549
- [key in keyof T]: key extends NonAnimatedProps
550
- ? key extends 'ref'
551
- ? TAugmentRef<T[key]>
552
- : T[key]
553
- : WithAnimatedValue<T[key]>;
554
- };
555
- export interface AnimatedComponent<T extends React_2.ComponentType<any>>
556
- extends React_2.FC<AnimatedProps<React_2.ComponentPropsWithRef<T>>> {}
557
- export type AnimatedComponentOptions = {
558
- collapsable?: boolean | undefined;
559
- };
560
- export function createAnimatedComponent<T extends React_2.ComponentType<any>>(
561
- component: T,
562
- options?: AnimatedComponentOptions
563
- ): AnimatedComponent<T>;
564
- const View: AnimatedComponent<typeof _View>;
565
- const Image: AnimatedComponent<typeof _Image>;
566
- const Text: AnimatedComponent<typeof _Text>;
567
- const ScrollView: AnimatedComponent<typeof _ScrollView>;
568
- export class FlatList<ItemT = any> extends FlatListComponent<
569
- ItemT,
570
- AnimatedProps<FlatListProps<ItemT>>
571
- > {}
572
- export class SectionList<
573
- ItemT = any,
574
- SectionT = DefaultSectionT,
575
- > extends SectionListComponent<
576
- AnimatedProps<SectionListProps<ItemT, SectionT>>
577
- > {}
578
  }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
579
  export declare type AppConfig = {
580
  appKey: string;
581
- component?: ComponentProvider | undefined;
582
- run?: Runnable | undefined;
 
583
  };
 
584
  export declare namespace Appearance {
585
- export type AppearancePreferences = {
586
- colorScheme: ColorSchemeName;
587
- };
588
- export type AppearanceListener = (preferences: AppearancePreferences) => void;
589
- export function getColorScheme(): ColorSchemeName;
590
- export function setColorScheme(
591
- scheme: ColorSchemeName | null | undefined
592
- ): void;
593
- export function addChangeListener(
594
- listener: AppearanceListener
595
- ): NativeEventSubscription;
596
  }
 
 
 
 
 
 
 
 
 
597
  export declare namespace AppRegistry {
598
- export function setWrapperComponentProvider(
599
- provider: WrapperComponentProvider
600
- ): void;
601
- export function setRootViewStyleProvider(
602
- provider: RootViewStyleProvider
603
- ): void;
604
- export function registerConfig(config: AppConfig[]): void;
605
- export function registerComponent(
606
- appKey: string,
607
- getComponentFunc: ComponentProvider,
608
- section?: boolean
609
- ): string;
610
- export function registerRunnable(appKey: string, func: Runnable): string;
611
- export function registerSection(
 
 
 
 
612
- appKey: string,
613
- component: ComponentProvider
614
- ): void;
615
- export function getAppKeys(): string[];
616
- export function getSectionKeys(): string[];
617
- export function getSections(): Record<string, Runnable>;
618
- export function unmountApplicationComponentAtRootTag(rootTag: number): void;
619
- export function runApplication(appKey: string, appParameters: any): void;
620
- export function setSurfaceProps(
621
- appKey: string,
622
- appParameters: any,
623
- displayMode?: number
624
- ): void;
625
- export function getRunnable(appKey: string): Runnable | undefined;
626
- export function getRegistry(): {sections: string[]; runnables: Runnable[]};
627
- export function setComponentProviderInstrumentationHook(
628
- hook: ComponentProviderInstrumentationHook
629
- ): void;
 
 
630
- export function registerHeadlessTask(
631
- taskKey: string,
632
- taskProvider: TaskProvider
633
- ): void;
634
- export function registerCancellableHeadlessTask(
635
- taskKey: string,
 
 
636
- taskProvider: TaskProvider,
637
- taskCancelProvider: TaskCancelProvider
638
- ): void;
639
- export function startHeadlessTask(
640
- taskId: number,
641
- taskKey: string,
642
- data: any
643
- ): void;
644
- export function cancelHeadlessTask(taskId: number, taskKey: string): void;
645
  }
 
646
- export declare const AppState: AppStateStatic;
 
647
- export declare type AppState = AppStateStatic;
 
 
 
 
 
648
- export declare type AppStateEvent =
649
- | 'change'
650
- | 'memoryWarning'
651
- | 'blur'
652
- | 'focus';
653
- export declare interface AppStateStatic {
654
- currentState: AppStateStatus;
 
 
 
 
 
 
 
655
  isAvailable: boolean;
 
656
- addEventListener(
657
- type: AppStateEvent,
658
- listener: (state: AppStateStatus) => void
659
- ): NativeEventSubscription;
660
  }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
661
- export declare type AppStateStatus =
662
- | 'active'
663
- | 'background'
664
- | 'inactive'
665
- | 'unknown'
666
- | 'extension';
667
- export declare type BackgroundPropType =
668
- | RippleBackgroundPropType
 
669
- | ThemeAttributeBackgroundPropType;
 
670
- export declare const BackHandler: BackHandlerStatic;
 
671
- export declare type BackHandler = BackHandlerStatic;
 
672
- export declare interface BackHandlerStatic {
673
- exitApp(): void;
674
- addEventListener(
675
- eventName: BackPressEventName,
676
- handler: () => boolean | null | undefined
677
- ): NativeEventSubscription;
678
- }
679
- export declare type BackPressEventName = 'hardwareBackPress';
 
680
- export declare interface BaseBackgroundPropType {
681
- type: string;
682
- rippleRadius?: number | null | undefined;
 
683
- }
 
684
  declare function beginAsyncEvent(
685
  eventName: EventName,
686
  args?: EventArgs
687
  ): number;
 
688
  declare function beginEvent(eventName: EventName, args?: EventArgs): void;
 
 
 
 
 
 
 
 
 
 
 
689
- export declare type BlendMode =
690
- | 'normal'
691
- | 'multiply'
692
- | 'screen'
693
- | 'overlay'
 
694
- | 'darken'
695
- | 'lighten'
696
- | 'color-dodge'
697
- | 'color-burn'
698
- | 'hard-light'
699
- | 'soft-light'
700
- | 'difference'
 
 
701
- | 'exclusion'
702
- | 'hue'
703
- | 'saturation'
704
- | 'color'
 
 
705
- | 'luminosity';
 
706
  export declare type BoxShadowValue = {
707
  offsetX: number | string;
708
  offsetY: number | string;
709
- color?: string | undefined;
710
- blurRadius?: ColorValue | number | undefined;
711
- spreadDistance?: number | string | undefined;
712
- inset?: boolean | undefined;
713
  };
 
714
  declare type BubblingEventHandler<
715
  T,
716
  PaperName extends string | never = never,
717
  > = (event: NativeSyntheticEvent<T>) => void | Promise<void>;
 
 
 
 
 
718
- export declare class Button extends React_2.Component<ButtonProps> {}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
719
- export declare type ButtonProperties = ButtonProps;
720
- export declare interface ButtonProps
721
- extends Pick<
722
- TouchableNativeFeedbackProps & TouchableOpacityProps,
723
- | 'accessibilityLabel'
724
- | 'accessibilityState'
725
- | 'hasTVPreferredFocus'
726
- | 'nextFocusDown'
727
- | 'nextFocusForward'
728
- | 'nextFocusLeft'
729
- | 'nextFocusRight'
730
- | 'nextFocusUp'
731
- | 'testID'
732
- | 'disabled'
733
- | 'onPress'
734
- | 'touchSoundDisabled'
735
- > {
736
  title: string;
 
 
 
 
 
737
  color?: ColorValue | undefined;
738
- }
739
- export declare const Clipboard: ClipboardStatic;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
740
- export declare type Clipboard = ClipboardStatic;
 
741
- export declare interface ClipboardStatic {
742
  getString(): Promise<string>;
 
743
  setString(content: string): void;
 
 
 
 
 
 
 
 
 
 
 
744
- }
 
 
 
 
 
 
 
 
 
745
- export declare function codegenNativeCommands<T extends object>(
746
- options: Options<keyof T extends string ? keyof T : never>
747
  ): T;
 
 
 
 
 
748
- export declare function codegenNativeComponent<Props extends object>(
749
  componentName: string,
750
- options?: Options_2
751
  ): NativeComponentType<Props>;
 
752
- export declare namespace CodegenTypes {
753
  export {
754
  BubblingEventHandler,
755
  DirectEventHandler,
756
  Double,
757
  Float,
758
  Int32,
759
- UnsafeObject,
760
  UnsafeMixed,
761
  DefaultTypes,
762
  WithDefault,
763
  EventEmitter,
764
  };
765
  }
 
 
 
 
766
- export declare type ColorSchemeName = 'light' | 'dark' | null | undefined;
 
767
- export declare type ColorValue = string | OpaqueColorValue;
 
768
- export declare type ComponentProvider = () => React_2.ComponentType<any>;
 
769
  export declare type ComponentProviderInstrumentationHook = (
770
- component: ComponentProvider,
771
  scopedPerformanceLogger: IPerformanceLogger
772
- ) => React_2.ComponentType<any>;
 
773
- declare type Constructor<T> = new (...args: any[]) => T;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
774
  declare function counterEvent(eventName: EventName, value: number): void;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
775
  export declare type CursorValue = 'auto' | 'pointer';
 
 
 
776
- export declare type DataDetectorTypes =
777
  | 'phoneNumber'
778
  | 'link'
779
  | 'address'
780
  | 'calendarEvent'
@@ -782,699 +1946,1188 @@
782
  | 'flightNumber'
783
  | 'lookupSuggestion'
784
  | 'none'
785
  | 'all';
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
786
- export declare type DefaultSectionT = {
787
  [key: string]: any;
788
  };
 
789
  declare type DefaultTypes = number | boolean | string | ReadonlyArray<string>;
 
790
- export declare const DeviceEventEmitter: DeviceEventEmitterStatic;
 
 
 
 
 
791
- export declare interface DeviceEventEmitterStatic extends EventEmitter_2 {
792
- sharedSubscriber: EventSubscriptionVendor;
793
- new (): DeviceEventEmitterStatic;
794
- addListener(
795
- type: string,
796
- listener: (data: any) => void,
797
- context?: any
798
- ): EmitterSubscription;
799
  }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
800
- export declare const DevMenu: DevMenuStatic;
 
 
 
801
- export declare interface DevMenuStatic {
802
  show(): void;
803
- }
 
804
- export declare const DevSettings: DevSettingsStatic;
 
805
- export declare interface DevSettingsStatic extends NativeEventEmitter {
 
 
806
- addMenuItem(title: string, handler: () => any): void;
 
807
  reload(reason?: string): void;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
808
  }
 
809
- export declare interface Dimensions {
810
- get(dim: 'window' | 'screen'): ScaledSize;
811
- set(dims: {[key: string]: any}): void;
812
- addEventListener(
813
- type: 'change',
814
- handler: ({
815
- window,
816
- screen,
817
- }: {
818
- window: ScaledSize;
819
- screen: ScaledSize;
820
- }) => void
821
- ): EmitterSubscription;
 
822
- }
823
- export declare const Dimensions: Dimensions;
824
  export declare type DimensionValue =
825
  | number
 
826
  | 'auto'
827
- | `${number}%`
828
- | Animated.AnimatedNode
829
  | null;
 
830
  declare type DirectEventHandler<T, PaperName extends string | never = never> = (
831
  event: NativeSyntheticEvent<T>
832
  ) => void | Promise<void>;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
833
- export declare interface DocumentSelectionState extends EventEmitter_2 {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
834
- new (anchor: number, focus: number): DocumentSelectionState;
 
 
 
835
- update(anchor: number, focus: number): void;
 
836
- constrainLength(maxLength: number): void;
 
 
 
 
 
837
- focus(): void;
838
  blur(): void;
839
- hasFocus(): boolean;
840
- isCollapsed(): boolean;
 
841
- isBackward(): boolean;
842
- getAnchorOffset(): number;
843
- getFocusOffset(): number;
844
- getStartOffset(): number;
845
- getEndOffset(): number;
 
846
- overlaps(start: number, end: number): boolean;
847
  }
848
- declare type Double = number;
849
- export declare class DrawerLayoutAndroid extends DrawerLayoutAndroidBase {
850
- positions: DrawerPosition;
851
  openDrawer(): void;
 
852
  closeDrawer(): void;
 
 
 
 
 
 
 
 
 
 
 
853
  }
854
- export declare const DrawerLayoutAndroidBase: Constructor<NativeMethods> &
855
- typeof DrawerLayoutAndroidComponent;
856
- export declare class DrawerLayoutAndroidComponent extends React_2.Component<DrawerLayoutAndroidProps> {}
857
- export declare type DrawerLayoutAndroidProperties = DrawerLayoutAndroidProps;
 
 
 
858
- export declare interface DrawerLayoutAndroidProps extends ViewProps {
 
859
- drawerBackgroundColor?: ColorValue | undefined;
860
- drawerLockMode?: 'unlocked' | 'locked-closed' | 'locked-open' | undefined;
861
- drawerPosition?: 'left' | 'right' | undefined;
 
862
- drawerWidth?: number | undefined;
863
- keyboardDismissMode?: 'none' | 'on-drag' | undefined;
864
- onDrawerClose?: (() => void) | undefined;
865
- onDrawerOpen?: (() => void) | undefined;
866
- onDrawerSlide?: ((event: DrawerSlideEvent) => void) | undefined;
867
- onDrawerStateChanged?:
868
- | ((event: 'Idle' | 'Dragging' | 'Settling') => void)
869
- | undefined;
 
 
 
 
 
 
 
 
 
870
- renderNavigationView: () => React_2.JSX.Element;
 
871
- statusBarBackgroundColor?: ColorValue | undefined;
872
- }
873
- export declare interface DrawerPosition {
874
- Left: number;
875
- Right: number;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
876
- }
 
 
 
 
 
 
877
- export declare interface DrawerSlideEvent
 
 
 
 
 
878
- extends NativeSyntheticEvent<NativeTouchEvent> {}
 
879
  export declare type DropShadowValue = {
880
  offsetX: number | string;
881
  offsetY: number | string;
882
- standardDeviation?: number | string | undefined;
883
- color?: ColorValue | number | undefined;
884
  };
 
885
- export declare function DynamicColorIOS(
886
  tuple: DynamicColorIOSTuple
887
- ): OpaqueColorValue;
 
 
 
888
  export declare type DynamicColorIOSTuple = {
889
  light: ColorValue;
890
  dark: ColorValue;
891
- highContrastLight?: ColorValue | undefined;
892
- highContrastDark?: ColorValue | undefined;
893
  };
894
- export declare type Easing = EasingStatic;
895
- export declare const Easing: EasingStatic;
 
 
 
896
- export declare type EasingFunction = (value: number) => number;
 
897
- export declare interface EasingStatic {
898
- step0: EasingFunction;
 
899
- step1: EasingFunction;
 
900
- linear: EasingFunction;
 
901
- ease: EasingFunction;
 
902
- quad: EasingFunction;
 
903
- cubic: EasingFunction;
 
904
  poly(n: number): EasingFunction;
 
905
- sin: EasingFunction;
 
906
- circle: EasingFunction;
 
907
- exp: EasingFunction;
 
908
  elastic(bounciness: number): EasingFunction;
 
909
  back(s: number): EasingFunction;
 
910
- bounce: EasingFunction;
 
911
  bezier(x1: number, y1: number, x2: number, y2: number): EasingFunction;
 
912
  in(easing: EasingFunction): EasingFunction;
 
913
  out(easing: EasingFunction): EasingFunction;
 
914
  inOut(easing: EasingFunction): EasingFunction;
915
- }
 
 
 
 
 
916
- export declare interface EmitterSubscription extends EventSubscription {
 
 
 
917
- emitter: EventEmitter_2;
918
- listener: () => any;
919
- context: any;
920
- new (
921
- emitter: EventEmitter_2,
922
- subscriber: EventSubscriptionVendor,
923
- listener: () => any,
924
- context: any
925
- ): EmitterSubscription;
926
- remove(): void;
927
- }
 
928
  declare function endAsyncEvent(
929
  eventName: EventName,
930
  cookie: number,
931
  args?: EventArgs
932
  ): void;
 
 
 
933
  declare function endEvent(args?: EventArgs): void;
 
934
- export declare type EnterKeyHintType =
935
- | 'done'
936
- | 'go'
937
- | 'next'
 
 
938
- | 'search'
 
939
- | 'send';
 
940
- export declare type EnterKeyHintTypeAndroid = 'previous';
 
 
 
941
- export declare type EnterKeyHintTypeIOS = 'enter';
 
 
 
942
  export declare type EnterKeyHintTypeOptions =
943
  | EnterKeyHintType
944
  | EnterKeyHintTypeAndroid
945
  | EnterKeyHintTypeIOS;
 
946
- export declare type ErrorHandlerCallback = (
947
- error: any,
948
- isFatal?: boolean
949
- ) => void;
 
 
950
- declare interface ErrorUtils_2 {
951
- setGlobalHandler: (callback: ErrorHandlerCallback) => void;
952
- getGlobalHandler: () => ErrorHandlerCallback;
953
- }
954
  export {ErrorUtils_2 as ErrorUtils};
 
 
 
 
 
 
 
 
955
- declare type EventArgs = {[key: string]: string} | void | null;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
956
  declare type EventEmitter<T> = (
957
- handler: (arg: T) => void | Promise<void>
958
- ) => EventSubscription_2;
 
959
- declare class EventEmitter_2 {
960
- constructor(subscriber?: EventSubscriptionVendor | null);
961
- addListener(
962
- eventType: string,
963
- listener: (...args: any[]) => any,
964
- context?: any
965
- ): EmitterSubscription;
966
- removeAllListeners(eventType?: string): void;
 
 
 
 
 
 
 
 
967
- listenerCount(eventType: string): number;
968
- emit(eventType: string, ...params: any[]): void;
969
- }
 
970
  declare type EventName = string | (() => string);
 
971
- export declare interface EventSubscription {
972
- eventType: string;
973
- key: number;
974
- subscriber: EventSubscriptionVendor;
975
- new (subscriber: EventSubscriptionVendor): EventSubscription;
976
  remove(): void;
977
  }
 
978
- declare class EventSubscriptionVendor {
979
- constructor();
980
- addSubscription(
981
- eventType: string,
982
- subscription: EventSubscription
983
- ): EventSubscription;
984
- removeAllSubscriptions(eventType?: string): void;
 
985
- removeSubscription(subscription: any): void;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
986
- getSubscriptionsForType(eventType: string): EventSubscription[];
987
- }
 
988
- export declare const experimental_LayoutConformance: React_2.ComponentType<LayoutConformanceProps>;
 
 
 
 
 
 
 
 
 
 
989
- declare type Extras = {[key: string]: ExtraValue};
 
 
990
  declare type ExtraValue = number | string | boolean;
991
- export declare type Falsy = undefined | null | false | '';
992
- export declare type FetchResult = {
993
  NewData: 'UIBackgroundFetchResultNewData';
994
  NoData: 'UIBackgroundFetchResultNoData';
995
  ResultFailed: 'UIBackgroundFetchResultFailed';
996
  };
 
997
- export declare type FilterFunction =
 
998
- | {brightness: number | string}
 
 
999
- | {blur: number | string}
 
 
1000
- | {contrast: number | string}
 
 
1001
- | {grayscale: number | string}
 
 
1002
- | {hueRotate: number | string}
 
 
1003
- | {invert: number | string}
 
 
1004
- | {opacity: number | string}
 
 
1005
- | {saturate: number | string}
 
 
1006
- | {sepia: number | string}
 
 
1007
- | {dropShadow: DropShadowValue | string};
 
 
1008
- export declare function findNodeHandle(
1009
- componentOrHandle:
1010
- | null
1011
- | number
1012
- | React_2.Component<any, any>
1013
- | React_2.ComponentClass<any>
1014
- ): null | NodeHandle;
 
1015
- export declare class FlatList<ItemT = any> extends FlatListComponent<
1016
- ItemT,
1017
  FlatListProps<ItemT>
1018
- > {}
1019
- export declare abstract class FlatListComponent<
1020
- ItemT,
1021
- Props,
 
1022
- > extends React_2.Component<Props> {
 
1023
- scrollToEnd: (params?: {animated?: boolean | null | undefined}) => void;
 
 
1024
- scrollToIndex: (params: {
1025
- animated?: boolean | null | undefined;
1026
  index: number;
1027
- viewOffset?: number | undefined;
1028
- viewPosition?: number | undefined;
1029
- }) => void;
1030
- scrollToItem: (params: {
1031
- animated?: boolean | null | undefined;
1032
  item: ItemT;
1033
- viewOffset?: number | undefined;
1034
- viewPosition?: number | undefined;
1035
- }) => void;
1036
- scrollToOffset: (params: {
1037
- animated?: boolean | null | undefined;
1038
  offset: number;
1039
- }) => void;
1040
- recordInteraction: () => void;
1041
- flashScrollIndicators: () => void;
1042
- getScrollResponder: () => React_2.JSX.Element | null | undefined;
1043
- getNativeScrollRef: () =>
1044
- | React_2.ElementRef<typeof View>
1045
- | React_2.ElementRef<typeof ScrollViewComponent>
1046
- | null
1047
- | undefined;
1048
- getScrollableNode: () => any;
1049
- setNativeProps: (props: {[key: string]: unknown}) => void;
 
 
 
1050
  }
 
1051
- export declare type FlatListProperties<ItemT> = FlatListProps<ItemT>;
 
 
 
 
 
1052
- export declare interface FlatListProps<ItemT>
 
1053
- extends VirtualizedListProps<ItemT> {
1054
- columnWrapperStyle?: StyleProp<ViewStyle> | undefined;
1055
- keyboardShouldPersistTaps?:
1056
- | boolean
1057
- | 'always'
1058
- | 'never'
 
 
1059
- | 'handled'
 
 
 
1060
- | undefined;
1061
- data: ArrayLike<ItemT> | null | undefined;
1062
- extraData?: any | undefined;
1063
- getItemLayout?:
1064
- | ((
1065
- data: ArrayLike<ItemT> | null | undefined,
1066
- index: number
1067
- ) => {length: number; offset: number; index: number})
1068
- | undefined;
1069
- horizontal?: boolean | null | undefined;
1070
- initialNumToRender?: number | undefined;
1071
- initialScrollIndex?: number | null | undefined;
1072
- keyExtractor?: ((item: ItemT, index: number) => string) | undefined;
 
1073
- legacyImplementation?: boolean | undefined;
 
 
 
 
 
 
1074
- numColumns?: number | undefined;
 
 
 
 
 
 
 
 
 
 
 
 
1075
- onRefresh?: (() => void) | null | undefined;
1076
- onViewableItemsChanged?:
1077
- | ((info: {
1078
- viewableItems: Array<ViewToken<ItemT>>;
1079
- changed: Array<ViewToken<ItemT>>;
1080
- }) => void)
1081
- | null
1082
- | undefined;
1083
- refreshing?: boolean | null | undefined;
1084
- renderItem: ListRenderItem<ItemT> | null | undefined;
1085
- viewabilityConfig?: ViewabilityConfig | undefined;
1086
- removeClippedSubviews?: boolean | undefined;
 
 
 
 
 
1087
- fadingEdgeLength?: number | undefined;
 
 
 
 
 
 
 
 
 
 
1088
  }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1089
- export declare type FlexAlignType =
 
 
1090
- | 'flex-start'
1091
- | 'flex-end'
1092
- | 'center'
1093
- | 'stretch'
 
1094
- | 'baseline';
 
 
 
 
 
 
 
 
 
 
 
1095
- export declare interface FlexStyle {
1096
- alignContent?:
1097
- | 'flex-start'
1098
- | 'flex-end'
1099
- | 'center'
1100
- | 'stretch'
1101
- | 'space-between'
1102
- | 'space-around'
1103
- | 'space-evenly'
1104
  | undefined;
 
1105
- alignItems?: FlexAlignType | undefined;
1106
- alignSelf?: 'auto' | FlexAlignType | undefined;
1107
- aspectRatio?: number | string | undefined;
1108
- borderBottomWidth?: number | undefined;
1109
- borderEndWidth?: number | undefined;
1110
- borderLeftWidth?: number | undefined;
1111
- borderRightWidth?: number | undefined;
1112
- borderStartWidth?: number | undefined;
1113
- borderTopWidth?: number | undefined;
1114
- borderWidth?: number | undefined;
1115
- bottom?: DimensionValue | undefined;
1116
- boxSizing?: 'border-box' | 'content-box' | undefined;
1117
- display?: 'none' | 'flex' | 'contents' | undefined;
1118
- end?: DimensionValue | undefined;
1119
- flex?: number | undefined;
1120
- flexBasis?: DimensionValue | undefined;
1121
- flexDirection?:
1122
- | 'row'
1123
- | 'column'
1124
- | 'row-reverse'
1125
- | 'column-reverse'
1126
  | undefined;
1127
- rowGap?: number | string | undefined;
1128
- gap?: number | string | undefined;
1129
- columnGap?: number | string | undefined;
1130
- flexGrow?: number | undefined;
1131
- flexShrink?: number | undefined;
1132
- flexWrap?: 'wrap' | 'nowrap' | 'wrap-reverse' | undefined;
 
 
 
 
 
 
 
1133
- height?: DimensionValue | undefined;
1134
- justifyContent?:
1135
- | 'flex-start'
1136
- | 'flex-end'
1137
- | 'center'
1138
- | 'space-between'
1139
- | 'space-around'
1140
- | 'space-evenly'
1141
  | undefined;
1142
- left?: DimensionValue | undefined;
1143
- margin?: DimensionValue | undefined;
1144
- marginBottom?: DimensionValue | undefined;
1145
- marginEnd?: DimensionValue | undefined;
1146
- marginHorizontal?: DimensionValue | undefined;
1147
- marginLeft?: DimensionValue | undefined;
1148
- marginRight?: DimensionValue | undefined;
1149
- marginStart?: DimensionValue | undefined;
1150
- marginTop?: DimensionValue | undefined;
1151
- marginVertical?: DimensionValue | undefined;
1152
- maxHeight?: DimensionValue | undefined;
1153
- maxWidth?: DimensionValue | undefined;
1154
- minHeight?: DimensionValue | undefined;
1155
- minWidth?: DimensionValue | undefined;
1156
- overflow?: 'visible' | 'hidden' | 'scroll' | undefined;
1157
- padding?: DimensionValue | undefined;
1158
- paddingBottom?: DimensionValue | undefined;
1159
- paddingEnd?: DimensionValue | undefined;
1160
- paddingHorizontal?: DimensionValue | undefined;
1161
- paddingLeft?: DimensionValue | undefined;
1162
- paddingRight?: DimensionValue | undefined;
1163
- paddingStart?: DimensionValue | undefined;
1164
- paddingTop?: DimensionValue | undefined;
1165
- paddingVertical?: DimensionValue | undefined;
1166
- position?: 'absolute' | 'relative' | 'static' | undefined;
1167
- right?: DimensionValue | undefined;
1168
- start?: DimensionValue | undefined;
1169
- top?: DimensionValue | undefined;
1170
- width?: DimensionValue | undefined;
1171
- zIndex?: number | undefined;
1172
- direction?: 'inherit' | 'ltr' | 'rtl' | undefined;
1173
- inset?: DimensionValue | undefined;
1174
- insetBlock?: DimensionValue | undefined;
1175
- insetBlockEnd?: DimensionValue | undefined;
1176
- insetBlockStart?: DimensionValue | undefined;
1177
- insetInline?: DimensionValue | undefined;
1178
- insetInlineEnd?: DimensionValue | undefined;
1179
- insetInlineStart?: DimensionValue | undefined;
1180
- marginBlock?: DimensionValue | undefined;
1181
- marginBlockEnd?: DimensionValue | undefined;
1182
- marginBlockStart?: DimensionValue | undefined;
1183
- marginInline?: DimensionValue | undefined;
1184
- marginInlineEnd?: DimensionValue | undefined;
1185
- marginInlineStart?: DimensionValue | undefined;
1186
- paddingBlock?: DimensionValue | undefined;
1187
- paddingBlockEnd?: DimensionValue | undefined;
1188
- paddingBlockStart?: DimensionValue | undefined;
1189
- paddingInline?: DimensionValue | undefined;
1190
- paddingInlineEnd?: DimensionValue | undefined;
1191
- paddingInlineStart?: DimensionValue | undefined;
1192
- }
1193
- declare type Float = number;
1194
- export declare type FontVariant =
1195
- | 'small-caps'
1196
- | 'oldstyle-nums'
1197
- | 'lining-nums'
1198
- | 'tabular-nums'
1199
- | 'common-ligatures'
1200
- | 'no-common-ligatures'
1201
- | 'discretionary-ligatures'
1202
- | 'no-discretionary-ligatures'
1203
- | 'historical-ligatures'
1204
- | 'no-historical-ligatures'
1205
- | 'contextual'
1206
- | 'no-contextual'
1207
- | 'proportional-nums'
1208
- | 'stylistic-one'
1209
- | 'stylistic-two'
1210
- | 'stylistic-three'
1211
- | 'stylistic-four'
1212
- | 'stylistic-five'
1213
- | 'stylistic-six'
1214
- | 'stylistic-seven'
1215
- | 'stylistic-eight'
1216
- | 'stylistic-nine'
1217
- | 'stylistic-ten'
1218
- | 'stylistic-eleven'
1219
- | 'stylistic-twelve'
1220
- | 'stylistic-thirteen'
1221
- | 'stylistic-fourteen'
1222
- | 'stylistic-fifteen'
1223
- | 'stylistic-sixteen'
1224
- | 'stylistic-seventeen'
1225
- | 'stylistic-eighteen'
1226
- | 'stylistic-nineteen'
1227
- | 'stylistic-twenty';
1228
- export declare interface GestureResponderEvent
1229
- extends NativeSyntheticEvent<NativeTouchEvent> {}
1230
- export declare interface GestureResponderHandlers {
1231
  onStartShouldSetResponder?:
1232
- | ((event: GestureResponderEvent) => boolean)
1233
  | undefined;
1234
- onMoveShouldSetResponder?:
1235
- | ((event: GestureResponderEvent) => boolean)
1236
- | undefined;
1237
- onResponderEnd?: ((event: GestureResponderEvent) => void) | undefined;
1238
- onResponderGrant?: ((event: GestureResponderEvent) => void) | undefined;
1239
- onResponderReject?: ((event: GestureResponderEvent) => void) | undefined;
1240
- onResponderMove?: ((event: GestureResponderEvent) => void) | undefined;
1241
- onResponderRelease?: ((event: GestureResponderEvent) => void) | undefined;
1242
- onResponderStart?: ((event: GestureResponderEvent) => void) | undefined;
1243
- onResponderTerminationRequest?:
1244
- | ((event: GestureResponderEvent) => boolean)
1245
- | undefined;
1246
- onResponderTerminate?: ((event: GestureResponderEvent) => void) | undefined;
1247
  onStartShouldSetResponderCapture?:
1248
- | ((event: GestureResponderEvent) => boolean)
1249
  | undefined;
1250
- onMoveShouldSetResponderCapture?:
1251
- | ((event: GestureResponderEvent) => boolean)
1252
- | undefined;
1253
- }
1254
- declare function get<T extends TurboModule>(name: string): T | null;
 
 
 
 
 
1255
  declare function getEnforcing<T extends TurboModule>(name: string): T;
 
 
 
 
 
 
 
 
 
1256
- export declare type GradientValue = {
1257
  type: 'linearGradient';
1258
- direction?: string | undefined;
1259
  colorStops: ReadonlyArray<{
1260
- color: ColorValue | null;
1261
- positions?: ReadonlyArray<string[]> | undefined;
1262
  }>;
1263
  };
 
 
 
 
 
1264
  export declare type Handle = number;
 
 
 
 
 
1265
- export declare interface HostComponent<P>
1266
- extends Pick<
1267
- React_2.ComponentClass<P>,
1268
- Exclude<keyof React_2.ComponentClass<P>, 'new'>
1269
- > {
1270
- new (props: P, context?: any): React_2.Component<P> & HostInstance;
1271
- }
 
 
 
 
 
1272
  export declare type HostInstance = NativeMethods;
1273
- export declare const I18nManager: I18nManagerStatic;
1274
- export declare type I18nManager = I18nManagerStatic;
1275
- export declare interface I18nManagerStatic {
1276
- getConstants: () => {
1277
- isRTL: boolean;
 
1278
- doLeftAndRightSwapInRTL: boolean;
1279
- localeIdentifier?: string | null | undefined;
 
1280
- };
1281
- allowRTL: (allowRTL: boolean) => void;
1282
- forceRTL: (forceRTL: boolean) => void;
1283
- swapLeftAndRightInRTL: (swapLeftAndRight: boolean) => void;
 
1284
- isRTL: boolean;
1285
  doLeftAndRightSwapInRTL: boolean;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1286
  }
 
1287
- export declare class Image extends ImageBase {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1288
- static getSize(uri: string): Promise<ImageSize>;
1289
- static getSize(
1290
  uri: string,
1291
  success: (width: number, height: number) => void,
1292
- failure?: (error: any) => void
1293
  ): void;
1294
- static getSizeWithHeaders(
1295
  uri: string,
 
1296
- headers: {[index: string]: string}
 
1297
  ): Promise<ImageSize>;
1298
- static getSizeWithHeaders(
1299
  uri: string,
 
1300
- headers: {[index: string]: string},
 
1301
  success: (width: number, height: number) => void,
1302
- failure?: (error: any) => void
1303
  ): void;
1304
- static prefetch(url: string): Promise<boolean>;
1305
- static prefetchWithMetadata(
1306
  url: string,
1307
  queryRootName: string,
1308
- rootTag?: number
1309
  ): Promise<boolean>;
1310
- static abortPrefetch?(requestId: number): void;
1311
- static queryCache?(
1312
- urls: string[]
1313
- ): Promise<{[url: string]: 'memory' | 'disk' | 'disk/memory'}>;
1314
- static resolveAssetSource(
1315
- source: ImageSourcePropType
1316
- ): ImageResolvedAssetSource;
1317
- }
1318
- export declare const _Image: typeof Image;
1319
- export declare class ImageBackground extends ImageBackgroundBase {}
1320
- export declare const ImageBackgroundBase: Constructor<NativeMethods> &
1321
- typeof ImageBackgroundComponent;
1322
- export declare class ImageBackgroundComponent extends React_2.Component<ImageBackgroundProps> {}
1323
- export declare type ImageBackgroundProperties = ImageBackgroundProps;
1324
- export declare interface ImageBackgroundProps extends ImagePropsBase {
1325
- children?: React_2.ReactNode | undefined;
1326
- imageStyle?: StyleProp<ImageStyle> | undefined;
1327
- style?: StyleProp<ViewStyle> | undefined;
1328
- imageRef?(image: Image): void;
1329
- }
1330
- export declare const ImageBase: Constructor<NativeMethods> &
1331
- typeof ImageComponent;
1332
- export declare class ImageComponent extends React_2.Component<ImageProps> {}
1333
- export declare type ImageErrorEvent = NativeSyntheticEvent<ImageErrorEventData>;
 
 
 
1334
- export declare interface ImageErrorEventData {
1335
- error: any;
1336
- }
 
 
 
1337
- export declare type ImageLoadEvent = NativeSyntheticEvent<ImageLoadEventData>;
 
 
 
1338
- export declare interface ImageLoadEventData {
1339
  source: {
1340
  height: number;
1341
  width: number;
1342
  uri: string;
1343
  };
1344
- }
 
1345
- export declare interface ImageProgressEventDataIOS {
1346
  loaded: number;
1347
  total: number;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1348
- }
 
 
 
1349
- export declare type ImageProgressEventIOS =
1350
- NativeSyntheticEvent<ImageProgressEventDataIOS>;
1351
- export declare type ImageProperties = ImageProps;
1352
- export declare type ImagePropertiesAndroid = ImagePropsAndroid;
1353
- export declare type ImagePropertiesIOS = ImagePropsIOS;
1354
- export declare type ImagePropertiesSourceOptions = ImageSourcePropType;
1355
- export declare interface ImageProps extends ImagePropsBase {
1356
- style?: StyleProp<ImageStyle> | undefined;
1357
- }
 
 
 
1358
- export declare interface ImagePropsAndroid {
1359
- resizeMethod?: 'auto' | 'resize' | 'scale' | 'none' | undefined;
1360
- fadeDuration?: number | undefined;
1361
- }
1362
- export declare interface ImagePropsBase
1363
- extends ImagePropsIOS,
1364
- ImagePropsAndroid,
1365
- AccessibilityProps {
1366
- id?: string | undefined;
 
 
 
 
1367
- onLayout?: ((event: LayoutChangeEvent) => void) | undefined;
1368
- onError?: ((error: ImageErrorEvent) => void) | undefined;
1369
- onLoad?: ((event: ImageLoadEvent) => void) | undefined;
1370
- onLoadEnd?: (() => void) | undefined;
1371
- onLoadStart?: (() => void) | undefined;
1372
  progressiveRenderingEnabled?: boolean | undefined;
1373
- borderRadius?: number | undefined;
1374
- borderTopLeftRadius?: number | undefined;
1375
- borderTopRightRadius?: number | undefined;
1376
- borderBottomLeftRadius?: number | undefined;
1377
- borderBottomRightRadius?: number | undefined;
1378
- resizeMode?: ImageResizeMode | undefined;
1379
- source?: ImageSourcePropType | undefined;
1380
- src?: string | undefined;
1381
- srcSet?: string | undefined;
1382
- loadingIndicatorSource?: ImageURISource | undefined;
1383
- testID?: string | undefined;
1384
- nativeID?: string | undefined;
1385
- defaultSource?: ImageURISource | ImageRequireSource | undefined;
1386
- alt?: string | undefined;
1387
- height?: number | undefined;
1388
- width?: number | undefined;
1389
- crossOrigin?: 'anonymous' | 'use-credentials' | undefined;
1390
- tintColor?: ColorValue | undefined;
1391
- referrerPolicy?:
1392
- | 'no-referrer'
1393
- | 'no-referrer-when-downgrade'
1394
- | 'origin'
1395
- | 'origin-when-cross-origin'
1396
- | 'same-origin'
1397
- | 'strict-origin'
1398
- | 'strict-origin-when-cross-origin'
1399
- | 'unsafe-url'
1400
- | undefined;
1401
- }
1402
- export declare interface ImagePropsIOS {
1403
- blurRadius?: number | undefined;
1404
- capInsets?: Insets | undefined;
1405
- onProgress?: ((event: ImageProgressEventIOS) => void) | undefined;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1406
  onPartialLoad?: (() => void) | undefined;
1407
- }
1408
- export declare type ImageRequireSource = number;
 
 
1409
- export declare type ImageResizeMode =
1410
- | 'cover'
1411
  | 'contain'
1412
- | 'stretch'
1413
  | 'repeat'
1414
- | 'center'
1415
  | 'none';
1416
- export declare interface ImageResizeModeStatic {
1417
- contain: ImageResizeMode;
1418
- cover: ImageResizeMode;
1419
- stretch: ImageResizeMode;
1420
- center: ImageResizeMode;
1421
- repeat: ImageResizeMode;
1422
- none: ImageResizeMode;
1423
- }
1424
- export declare interface ImageResolvedAssetSource {
 
1425
- height: number;
1426
  width: number;
1427
- scale: number;
1428
- uri: string;
1429
- }
1430
- export declare interface ImageSize {
1431
- width: number;
1432
  height: number;
1433
- }
 
1434
- export declare type ImageSourcePropType =
 
1435
  | ImageURISource
1436
- | ImageURISource[]
1437
- | ImageRequireSource;
1438
- export declare interface ImageStyle
1439
- extends FlexStyle,
1440
- ShadowStyleIOS,
1441
- TransformsStyle {
1442
- resizeMode?: ImageResizeMode | undefined;
1443
- backfaceVisibility?: 'visible' | 'hidden' | undefined;
1444
- borderBottomLeftRadius?: AnimatableNumericValue | string | undefined;
1445
- borderBottomRightRadius?: AnimatableNumericValue | string | undefined;
1446
- backgroundColor?: ColorValue | undefined;
1447
- borderColor?: ColorValue | undefined;
1448
- borderRadius?: AnimatableNumericValue | string | undefined;
1449
- borderTopLeftRadius?: AnimatableNumericValue | string | undefined;
1450
- borderTopRightRadius?: AnimatableNumericValue | string | undefined;
1451
- overflow?: 'visible' | 'hidden' | undefined;
1452
- overlayColor?: ColorValue | undefined;
1453
- tintColor?: ColorValue | undefined;
1454
- opacity?: AnimatableNumericValue | undefined;
1455
- objectFit?: 'cover' | 'contain' | 'fill' | 'scale-down' | 'none' | undefined;
1456
- cursor?: CursorValue | undefined;
1457
- }
1458
  export declare interface ImageURISource {
1459
- uri?: string | undefined;
 
1460
- bundle?: string | undefined;
 
1461
- method?: string | undefined;
 
 
 
 
 
 
 
1462
- headers?: {[key: string]: string} | undefined;
 
 
1463
- cache?: 'default' | 'reload' | 'force-cache' | 'only-if-cached' | undefined;
1464
- body?: string | undefined;
 
1465
- width?: number | undefined;
1466
- height?: number | undefined;
 
1467
- scale?: number | undefined;
1468
  }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1469
- export declare class InputAccessoryView extends React_2.Component<InputAccessoryViewProps> {}
 
1470
- export declare type InputAccessoryViewProperties = InputAccessoryViewProps;
 
 
 
1471
- export declare interface InputAccessoryViewProps {
1472
- backgroundColor?: ColorValue | undefined;
1473
- children?: React_2.ReactNode | undefined;
 
1474
  nativeID?: string | undefined;
1475
- style?: StyleProp<ViewStyle> | undefined;
 
1476
- }
 
1477
  export declare type InputModeOptions =
1478
  | 'none'
1479
  | 'text'
1480
  | 'decimal'
@@ -1482,35 +3135,139 @@
1482
  | 'tel'
1483
  | 'search'
1484
  | 'email'
1485
  | 'url';
 
 
 
 
 
 
 
 
 
 
 
1486
- export declare interface Insets {
 
1487
- top?: number | undefined;
1488
- left?: number | undefined;
1489
- bottom?: number | undefined;
 
1490
- right?: number | undefined;
1491
- }
1492
  declare type Int32 = number;
 
1493
- export declare const InteractionManager: InteractionManagerStatic;
 
 
 
 
 
1494
- export declare interface InteractionManagerStatic {
1495
  Events: {
1496
- interactionStart: string;
1497
- interactionComplete: string;
1498
  };
1499
- addListener(
1500
- eventType: string,
1501
- listener: (...args: any[]) => any,
1502
- context?: any
1503
- ): EmitterSubscription;
1504
- runAfterInteractions(task?: (() => any) | SimpleTask | PromiseTask): {
 
 
 
 
1505
- then: (onfulfilled?: () => any, onrejected?: () => any) => Promise<any>;
1506
- done: (...args: any[]) => any;
1507
  cancel: () => void;
1508
  };
 
1509
  createInteractionHandle(): Handle;
 
1510
  clearInteractionHandle(handle: Handle): void;
 
 
 
 
 
 
1511
  setDeadline(deadline: number): void;
 
 
 
 
 
 
 
1512
- }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1513
  declare interface IPerformanceLogger {
1514
  addTimespan(
1515
  key: string,
1516
  startTime: number,
@@ -1522,579 +3279,1041 @@
1522
  clear(): void;
1523
  clearCompleted(): void;
1524
  close(): void;
1525
  currentTimestamp(): number;
 
1526
- getExtras(): {[key: string]: ExtraValue | null};
 
 
1527
- getPoints(): {[key: string]: number | null};
 
 
1528
- getPointExtras(): {[key: string]: Extras | null};
 
 
1529
- getTimespans(): {[key: string]: Timespan | null};
 
1530
  hasTimespan(key: string): boolean;
1531
  isClosed(): boolean;
1532
  logEverything(): void;
1533
  markPoint(key: string, timestamp?: number, extras?: Extras): void;
1534
- removeExtra(key: string): ExtraValue | null;
1535
  setExtra(key: string, value: ExtraValue): void;
1536
  startTimespan(key: string, timestamp?: number, extras?: Extras): void;
1537
  stopTimespan(key: string, timestamp?: number, extras?: Extras): void;
1538
  }
 
1539
  declare function isEnabled(): boolean;
 
1540
- export declare const Keyboard: KeyboardStatic;
 
1541
- export declare class KeyboardAvoidingView extends KeyboardAvoidingViewBase {}
1542
- export declare const KeyboardAvoidingViewBase: Constructor<TimerMixin> &
1543
- typeof KeyboardAvoidingViewComponent;
1544
- export declare class KeyboardAvoidingViewComponent extends React_2.Component<KeyboardAvoidingViewProps> {}
1545
- export declare interface KeyboardAvoidingViewProps extends ViewProps {
 
1546
- behavior?: 'height' | 'position' | 'padding' | undefined;
1547
- contentContainerStyle?: StyleProp<ViewStyle> | undefined;
1548
- keyboardVerticalOffset?: number | undefined;
1549
- enabled?: boolean | undefined;
 
 
 
 
 
1550
  }
 
1551
- declare interface KeyboardEvent_2 extends Partial<KeyboardEventIOS> {
1552
- duration: number;
1553
- easing: KeyboardEventEasing;
 
 
 
 
 
1554
- endCoordinates: KeyboardMetrics;
 
 
 
 
1555
  }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1556
  export {KeyboardEvent_2 as KeyboardEvent};
 
 
 
 
 
 
 
 
 
 
1557
  export declare type KeyboardEventEasing =
1558
  | 'easeIn'
1559
  | 'easeInEaseOut'
1560
  | 'easeOut'
1561
  | 'linear'
1562
  | 'keyboard';
1563
- export declare interface KeyboardEventIOS {
1564
- startCoordinates: KeyboardMetrics;
1565
- isEventFromThisApp: boolean;
1566
- }
1567
- export declare type KeyboardEventListener = (event: KeyboardEvent_2) => void;
1568
- export declare type KeyboardEventName =
1569
- | 'keyboardWillShow'
1570
- | 'keyboardDidShow'
1571
- | 'keyboardWillHide'
1572
- | 'keyboardDidHide'
1573
- | 'keyboardWillChangeFrame'
1574
- | 'keyboardDidChangeFrame';
1575
- export declare type KeyboardMetrics = {
1576
  screenX: number;
1577
  screenY: number;
1578
  width: number;
1579
  height: number;
1580
- };
1581
- export declare interface KeyboardStatic extends NativeEventEmitter {
1582
- dismiss: () => void;
1583
- addListener: (
1584
- eventType: KeyboardEventName,
1585
- listener: KeyboardEventListener
1586
- ) => EmitterSubscription;
1587
- scheduleLayoutAnimation: (event: KeyboardEvent_2) => void;
1588
- isVisible(): boolean;
1589
- metrics(): KeyboardMetrics | undefined;
1590
- }
1591
- export declare type KeyboardType =
1592
  | 'default'
 
 
 
1593
  | 'number-pad'
1594
  | 'decimal-pad'
1595
- | 'numeric'
 
 
 
1596
  | 'email-address'
 
1597
  | 'phone-pad'
 
 
1598
  | 'url';
 
1599
- export declare type KeyboardTypeAndroid = 'visible-password';
 
 
 
1600
- export declare type KeyboardTypeIOS =
1601
  | 'ascii-capable'
1602
  | 'numbers-and-punctuation'
1603
  | 'name-phone-pad'
1604
  | 'twitter'
1605
- | 'web-search';
 
 
 
 
 
 
 
 
 
 
1606
  export declare type KeyboardTypeOptions =
1607
  | KeyboardType
 
1608
- | KeyboardTypeAndroid
 
 
 
1609
- | KeyboardTypeIOS;
 
 
1610
- export declare const LayoutAnimation: LayoutAnimationStatic;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1611
- export declare type LayoutAnimation = LayoutAnimationStatic;
1612
- export declare interface LayoutAnimationAnim {
1613
- duration?: number | undefined;
1614
- delay?: number | undefined;
1615
- springDamping?: number | undefined;
1616
- initialVelocity?: number | undefined;
1617
- type?: LayoutAnimationType | undefined;
1618
- property?: LayoutAnimationProperty | undefined;
1619
- }
1620
- export declare interface LayoutAnimationConfig {
1621
  duration: number;
1622
- create?: LayoutAnimationAnim | undefined;
1623
- update?: LayoutAnimationAnim | undefined;
1624
- delete?: LayoutAnimationAnim | undefined;
1625
- }
 
1626
- export declare type LayoutAnimationProperties = {
1627
  [prop in LayoutAnimationProperty]: prop;
1628
- };
 
1629
  export declare type LayoutAnimationProperty =
1630
  | 'opacity'
1631
  | 'scaleX'
1632
  | 'scaleY'
1633
  | 'scaleXY';
1634
- export declare interface LayoutAnimationStatic {
1635
- configureNext: (
1636
- config: LayoutAnimationConfig,
1637
- onAnimationDidEnd?: () => void,
1638
- onAnimationDidFail?: () => void
1639
- ) => void;
1640
- create: (
1641
- duration: number,
1642
- type?: LayoutAnimationType,
1643
- creationProp?: LayoutAnimationProperty
1644
- ) => LayoutAnimationConfig;
1645
- Types: LayoutAnimationTypes;
1646
- Properties: LayoutAnimationProperties;
1647
- configChecker: (shapeTypes: {[key: string]: any}) => any;
1648
- Presets: {
1649
- easeInEaseOut: LayoutAnimationConfig;
1650
- linear: LayoutAnimationConfig;
1651
- spring: LayoutAnimationConfig;
1652
- };
1653
- easeInEaseOut: (onAnimationDidEnd?: () => void) => void;
1654
- linear: (onAnimationDidEnd?: () => void) => void;
1655
- spring: (onAnimationDidEnd?: () => void) => void;
1656
- }
1657
  export declare type LayoutAnimationType =
1658
  | 'spring'
1659
  | 'linear'
1660
  | 'easeInEaseOut'
1661
  | 'easeIn'
1662
  | 'easeOut'
1663
  | 'keyboard';
 
1664
- export declare type LayoutAnimationTypes = {
1665
  [type in LayoutAnimationType]: type;
1666
- };
1667
- export declare type LayoutChangeEvent = NativeSyntheticEvent<{
1668
- layout: LayoutRectangle;
1669
  }>;
 
 
 
 
 
 
 
1670
- export declare type LayoutConformanceProps = {
1671
  mode: 'strict' | 'compatibility';
1672
- children: React_2.ReactNode;
1673
- };
 
1674
- export declare interface LayoutRectangle {
1675
  x: number;
1676
  y: number;
1677
  width: number;
1678
  height: number;
1679
- }
 
 
 
 
 
1680
- export declare const Linking: LinkingImpl;
 
1681
- export declare type Linking = LinkingImpl;
 
 
 
 
 
 
 
1682
- export declare interface LinkingImpl extends NativeEventEmitter {
 
 
1683
- addEventListener(
1684
- type: 'url',
1685
- handler: (event: {url: string}) => void
1686
- ): EmitterSubscription;
1687
- openURL(url: string): Promise<any>;
1688
  canOpenURL(url: string): Promise<boolean>;
1689
- getInitialURL(): Promise<string | null>;
1690
  openSettings(): Promise<void>;
 
1691
  sendIntent(
1692
  action: string,
 
 
1693
- extras?: Array<{key: string; value: string | number | boolean}>
 
1694
  ): Promise<void>;
1695
  }
 
 
 
 
 
1696
- export declare const LogBox: LogBoxStatic;
 
1697
- export declare type LogBox = LogBoxStatic;
 
1698
- export declare interface LogBoxStatic {
 
 
 
 
1699
- ignoreLogs(patterns: (string | RegExp)[]): void;
1700
- ignoreAllLogs(ignore?: boolean): void;
1701
- install(): void;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1702
- uninstall(): void;
 
 
 
 
 
 
 
1703
- }
1704
- export declare interface MatrixTransform {
1705
- matrix: AnimatableNumericValue[];
1706
- }
1707
- export declare type MaximumOneOf<
1708
- T,
1709
- K extends keyof T = keyof T,
1710
- > = K extends keyof T
1711
- ? {[P in K]: T[K]} & {[P in Exclude<keyof T, K>]?: never}
1712
- : never;
1713
  export declare type MeasureInWindowOnSuccessCallback = (
1714
  x: number,
1715
  y: number,
1716
  width: number,
1717
  height: number
1718
  ) => void;
 
 
 
 
 
 
 
 
1719
  export declare type MeasureLayoutOnSuccessCallback = (
1720
  left: number,
1721
  top: number,
1722
  width: number,
1723
  height: number
1724
  ) => void;
 
 
 
 
 
 
 
 
1725
  export declare type MeasureOnSuccessCallback = (
1726
  x: number,
1727
  y: number,
1728
  width: number,
1729
  height: number,
1730
  pageX: number,
1731
  pageY: number
1732
  ) => void;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1733
- export declare class Modal extends React_2.Component<ModalProps> {}
 
1734
- export declare interface ModalBaseProps {
1735
- animated?: boolean | undefined;
 
1736
- animationType?: 'none' | 'slide' | 'fade' | undefined;
 
1737
  transparent?: boolean | undefined;
 
1738
  visible?: boolean | undefined;
 
1739
- onRequestClose?: ((event: NativeSyntheticEvent<any>) => void) | undefined;
 
1740
- onShow?: ((event: NativeSyntheticEvent<any>) => void) | undefined;
 
1741
- backdropColor?: ColorValue | undefined;
 
 
1742
- }
 
1743
- export declare type ModalProperties = ModalProps;
 
1744
- export declare type ModalProps = ModalBaseProps &
1745
- ModalPropsIOS &
 
 
1746
- ModalPropsAndroid &
1747
- ViewProps;
1748
- export declare interface ModalPropsAndroid {
1749
  hardwareAccelerated?: boolean | undefined;
 
1750
  statusBarTranslucent?: boolean | undefined;
 
1751
  navigationBarTranslucent?: boolean | undefined;
1752
- }
 
1753
- export declare interface ModalPropsIOS {
1754
  presentationStyle?:
1755
- | 'fullScreen'
1756
- | 'pageSheet'
1757
- | 'formSheet'
1758
- | 'overFullScreen'
1759
  | undefined;
 
1760
  supportedOrientations?:
1761
- | Array<
1762
  | 'portrait'
1763
  | 'portrait-upside-down'
1764
  | 'landscape'
1765
  | 'landscape-left'
1766
  | 'landscape-right'
1767
  >
1768
  | undefined;
 
1769
  onDismiss?: (() => void) | undefined;
1770
- onOrientationChange?:
1771
- | ((event: NativeSyntheticEvent<any>) => void)
1772
- | undefined;
1773
- }
 
 
 
 
 
1774
- export declare type Module = Object;
 
 
 
 
 
 
 
1775
- declare interface MouseEvent_2 extends NativeSyntheticEvent<NativeMouseEvent> {}
 
 
 
 
 
 
 
 
1776
  export {MouseEvent_2 as MouseEvent};
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1777
- export declare const NativeAppEventEmitter: RCTNativeAppEventEmitter;
 
 
 
 
 
 
 
1778
  declare type NativeComponentType<T> = HostComponent<T>;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1779
- export declare class NativeEventEmitter extends EventEmitter_2 {
 
 
 
 
 
1780
- constructor(nativeModule?: NativeModule);
1781
- addListener(
1782
- eventType: string,
1783
- listener: (event: any) => void,
1784
- context?: Object
1785
- ): EmitterSubscription;
 
 
 
 
1786
- removeAllListeners(eventType: string): void;
 
 
 
 
 
1787
  }
 
1788
- export declare interface NativeEventSubscription {
1789
- remove(): void;
1790
- }
1791
  export declare interface NativeMethods {
 
 
 
 
1792
  measure(callback: MeasureOnSuccessCallback): void;
 
1793
  measureInWindow(callback: MeasureInWindowOnSuccessCallback): void;
 
1794
  measureLayout(
1795
- relativeToNativeComponentRef: HostInstance | number,
1796
  onSuccess: MeasureLayoutOnSuccessCallback,
1797
  onFail?: () => void
1798
  ): void;
 
1799
- setNativeProps(nativeProps: object): void;
1800
- focus(): void;
1801
- blur(): void;
1802
  }
1803
- export declare type NativeMethodsMixin = NativeMethods;
1804
- export declare type NativeMethodsMixinType = NativeMethods;
1805
- export declare type NativeModule = {
1806
- addListener: (eventType: string) => void;
1807
- removeListeners: (count: number) => void;
1808
- };
1809
- export declare const NativeModules: NativeModulesStatic;
1810
- export declare interface NativeModulesStatic {
1811
- [name: string]: any;
1812
  }
 
 
 
 
 
 
 
 
 
1813
  export declare interface NativeMouseEvent extends NativeUIEvent {
1814
  readonly screenX: number;
 
1815
  readonly screenY: number;
 
1816
  readonly pageX: number;
 
1817
  readonly pageY: number;
 
1818
  readonly clientX: number;
 
1819
  readonly clientY: number;
 
1820
  readonly x: number;
 
1821
  readonly y: number;
 
1822
  readonly ctrlKey: boolean;
 
1823
  readonly shiftKey: boolean;
 
1824
  readonly altKey: boolean;
 
1825
  readonly metaKey: boolean;
 
1826
  readonly button: number;
 
1827
  readonly buttons: number;
 
1828
  readonly relatedTarget: null | number | HostInstance;
 
1829
  readonly offsetX: number;
 
1830
  readonly offsetY: number;
1831
  }
 
1832
  export declare interface NativePointerEvent extends NativeMouseEvent {
1833
  readonly pointerId: number;
 
1834
  readonly width: number;
 
1835
  readonly height: number;
 
1836
  readonly pressure: number;
 
1837
  readonly tangentialPressure: number;
 
1838
  readonly tiltX: number;
 
1839
  readonly tiltY: number;
 
1840
  readonly twist: number;
 
1841
  readonly pointerType: string;
 
1842
  readonly isPrimary: boolean;
1843
  }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1844
- export declare interface NativeScrollEvent {
1845
  contentInset: NativeScrollRectangle;
1846
  contentOffset: NativeScrollPoint;
1847
  contentSize: NativeScrollSize;
1848
  layoutMeasurement: NativeScrollSize;
1849
- velocity?: NativeScrollVelocity | undefined;
1850
- zoomScale: number;
 
 
1851
- targetContentOffset?: NativeScrollPoint | undefined;
1852
- }
 
1853
- export declare interface NativeScrollPoint {
1854
- x: number;
1855
  y: number;
1856
- }
1857
- export declare interface NativeScrollRectangle {
1858
- left: number;
1859
- top: number;
 
 
 
1860
  bottom: number;
 
1861
  right: number;
 
1862
- }
 
1863
- export declare interface NativeScrollSize {
1864
  height: number;
1865
  width: number;
1866
- }
 
1867
- export declare interface NativeScrollVelocity {
1868
- x: number;
1869
  y: number;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1870
- }
 
 
1871
- export declare interface NativeSyntheticEvent<T>
1872
- extends React_2.BaseSyntheticEvent<T, HostInstance, HostInstance> {}
 
 
 
 
1873
- export declare interface NativeTouchEvent {
1874
- changedTouches: NativeTouchEvent[];
 
 
 
1875
- identifier: string;
 
1876
  locationX: number;
 
1877
  locationY: number;
 
1878
  pageX: number;
 
1879
  pageY: number;
 
1880
- target: string;
 
1881
  timestamp: number;
 
1882
- touches: NativeTouchEvent[];
 
 
1883
- force?: number | undefined;
1884
- }
1885
  export declare interface NativeUIEvent {
1886
  readonly detail: number;
1887
  }
1888
- export declare type NodeHandle = number;
1889
- export declare type OpaqueColorValue = symbol & {__TYPE__: 'Color'};
1890
- declare interface Options<T extends string> {
1891
- readonly supportedCommands: ReadonlyArray<T>;
1892
- }
1893
- declare interface Options_2 {
1894
- readonly interfaceOnly?: boolean | undefined;
1895
- readonly paperComponentName?: string | undefined;
1896
- readonly paperComponentNameDeprecated?: string | undefined;
1897
- readonly excludedPlatforms?: ReadonlyArray<'iOS' | 'android'> | undefined;
1898
- }
1899
- export declare const PanResponder: PanResponderStatic;
1900
- export declare type PanResponder = PanResponderStatic;
1901
- export declare interface PanResponderCallbacks {
1902
- onMoveShouldSetPanResponder?:
1903
- | ((
1904
- e: GestureResponderEvent,
1905
- gestureState: PanResponderGestureState
1906
- ) => boolean)
1907
- | undefined;
1908
- onStartShouldSetPanResponder?:
1909
- | ((
1910
- e: GestureResponderEvent,
1911
- gestureState: PanResponderGestureState
1912
- ) => boolean)
1913
- | undefined;
1914
- onPanResponderGrant?:
1915
- | ((
1916
- e: GestureResponderEvent,
1917
- gestureState: PanResponderGestureState
1918
- ) => void)
1919
- | undefined;
1920
- onPanResponderMove?:
1921
- | ((
1922
- e: GestureResponderEvent,
1923
- gestureState: PanResponderGestureState
1924
- ) => void)
1925
- | undefined;
1926
- onPanResponderRelease?:
1927
- | ((
1928
- e: GestureResponderEvent,
1929
- gestureState: PanResponderGestureState
1930
- ) => void)
1931
- | undefined;
1932
- onPanResponderTerminate?:
1933
- | ((
1934
- e: GestureResponderEvent,
1935
- gestureState: PanResponderGestureState
1936
- ) => void)
1937
- | undefined;
1938
- onMoveShouldSetPanResponderCapture?:
1939
- | ((
1940
- e: GestureResponderEvent,
1941
- gestureState: PanResponderGestureState
1942
- ) => boolean)
1943
- | undefined;
1944
- onStartShouldSetPanResponderCapture?:
1945
- | ((
1946
- e: GestureResponderEvent,
1947
- gestureState: PanResponderGestureState
1948
- ) => boolean)
1949
- | undefined;
1950
- onPanResponderReject?:
1951
- | ((
1952
- e: GestureResponderEvent,
1953
- gestureState: PanResponderGestureState
1954
- ) => void)
1955
- | undefined;
1956
- onPanResponderStart?:
1957
- | ((
1958
- e: GestureResponderEvent,
1959
- gestureState: PanResponderGestureState
1960
- ) => void)
1961
- | undefined;
1962
- onPanResponderEnd?:
1963
- | ((
1964
- e: GestureResponderEvent,
1965
- gestureState: PanResponderGestureState
1966
- ) => void)
1967
- | undefined;
1968
- onPanResponderTerminationRequest?:
1969
- | ((
1970
- e: GestureResponderEvent,
1971
- gestureState: PanResponderGestureState
1972
- ) => boolean)
1973
- | undefined;
1974
- onShouldBlockNativeResponder?:
1975
- | ((
1976
- e: GestureResponderEvent,
1977
- gestureState: PanResponderGestureState
1978
- ) => boolean)
1979
- | undefined;
1980
- }
1981
- export declare interface PanResponderGestureState {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1982
  stateID: number;
 
1983
  moveX: number;
 
1984
  moveY: number;
 
1985
  x0: number;
 
1986
  y0: number;
 
1987
  dx: number;
 
1988
  dy: number;
 
1989
  vx: number;
 
1990
  vy: number;
 
1991
  numberActiveTouches: number;
1992
- _accountsForMovesUpTo: number;
1993
- }
1994
- export declare interface PanResponderInstance {
1995
- panHandlers: GestureResponderHandlers;
1996
- }
1997
- export declare interface PanResponderStatic {
1998
- create(config: PanResponderCallbacks): PanResponderInstance;
1999
- }
2000
- export declare type Permission =
2001
- | 'android.permission.READ_CALENDAR'
2002
- | 'android.permission.WRITE_CALENDAR'
2003
- | 'android.permission.CAMERA'
2004
- | 'android.permission.READ_CONTACTS'
2005
- | 'android.permission.WRITE_CONTACTS'
2006
- | 'android.permission.GET_ACCOUNTS'
2007
- | 'android.permission.ACCESS_BACKGROUND_LOCATION'
2008
- | 'android.permission.ACCESS_FINE_LOCATION'
2009
- | 'android.permission.ACCESS_COARSE_LOCATION'
2010
- | 'android.permission.RECORD_AUDIO'
2011
- | 'android.permission.READ_PHONE_STATE'
2012
- | 'android.permission.CALL_PHONE'
2013
- | 'android.permission.READ_CALL_LOG'
2014
- | 'android.permission.WRITE_CALL_LOG'
2015
- | 'com.android.voicemail.permission.ADD_VOICEMAIL'
2016
- | 'com.android.voicemail.permission.READ_VOICEMAIL'
2017
- | 'com.android.voicemail.permission.WRITE_VOICEMAIL'
2018
- | 'android.permission.USE_SIP'
2019
- | 'android.permission.PROCESS_OUTGOING_CALLS'
2020
- | 'android.permission.BODY_SENSORS'
2021
- | 'android.permission.BODY_SENSORS_BACKGROUND'
2022
- | 'android.permission.SEND_SMS'
2023
- | 'android.permission.RECEIVE_SMS'
2024
- | 'android.permission.READ_SMS'
2025
- | 'android.permission.RECEIVE_WAP_PUSH'
2026
- | 'android.permission.RECEIVE_MMS'
2027
- | 'android.permission.READ_EXTERNAL_STORAGE'
2028
- | 'android.permission.READ_MEDIA_IMAGES'
2029
- | 'android.permission.READ_MEDIA_VIDEO'
2030
- | 'android.permission.READ_MEDIA_AUDIO'
2031
- | 'android.permission.READ_MEDIA_VISUAL_USER_SELECTED'
2032
- | 'android.permission.WRITE_EXTERNAL_STORAGE'
2033
- | 'android.permission.BLUETOOTH_CONNECT'
2034
- | 'android.permission.BLUETOOTH_SCAN'
2035
- | 'android.permission.BLUETOOTH_ADVERTISE'
2036
- | 'android.permission.ACCESS_MEDIA_LOCATION'
2037
- | 'android.permission.ACCEPT_HANDOVER'
2038
- | 'android.permission.ACTIVITY_RECOGNITION'
2039
- | 'android.permission.ANSWER_PHONE_CALLS'
2040
- | 'android.permission.READ_PHONE_NUMBERS'
2041
- | 'android.permission.UWB_RANGING'
2042
- | 'android.permission.POST_NOTIFICATIONS'
2043
- | 'android.permission.NEARBY_WIFI_DEVICES';
2044
- export declare const PermissionsAndroid: PermissionsAndroidStatic;
2045
- export declare type PermissionsAndroid = PermissionsAndroidStatic;
2046
- export declare interface PermissionsAndroidStatic {
2047
- RESULTS: {
2048
- [key in 'GRANTED' | 'DENIED' | 'NEVER_ASK_AGAIN']: PermissionStatus;
2049
- };
2050
- PERMISSIONS: {
2051
- [key in
2052
- | 'READ_CALENDAR'
2053
- | 'WRITE_CALENDAR'
2054
- | 'CAMERA'
2055
- | 'READ_CONTACTS'
2056
- | 'WRITE_CONTACTS'
2057
- | 'GET_ACCOUNTS'
2058
- | 'ACCESS_FINE_LOCATION'
2059
- | 'ACCESS_COARSE_LOCATION'
2060
- | 'ACCESS_BACKGROUND_LOCATION'
2061
- | 'RECORD_AUDIO'
2062
- | 'READ_PHONE_STATE'
2063
- | 'CALL_PHONE'
2064
- | 'READ_CALL_LOG'
2065
- | 'WRITE_CALL_LOG'
2066
- | 'ADD_VOICEMAIL'
2067
- | 'READ_VOICEMAIL'
2068
- | 'WRITE_VOICEMAIL'
2069
- | 'USE_SIP'
2070
- | 'PROCESS_OUTGOING_CALLS'
2071
- | 'BODY_SENSORS'
2072
- | 'BODY_SENSORS_BACKGROUND'
2073
- | 'SEND_SMS'
2074
- | 'RECEIVE_SMS'
2075
- | 'READ_SMS'
2076
- | 'RECEIVE_WAP_PUSH'
2077
- | 'RECEIVE_MMS'
2078
- | 'READ_EXTERNAL_STORAGE'
2079
- | 'READ_MEDIA_IMAGES'
2080
- | 'READ_MEDIA_VIDEO'
2081
- | 'READ_MEDIA_AUDIO'
2082
- | 'READ_MEDIA_VISUAL_USER_SELECTED'
2083
- | 'WRITE_EXTERNAL_STORAGE'
2084
- | 'BLUETOOTH_CONNECT'
2085
- | 'BLUETOOTH_SCAN'
2086
- | 'BLUETOOTH_ADVERTISE'
2087
- | 'ACCESS_MEDIA_LOCATION'
2088
- | 'ACCEPT_HANDOVER'
2089
- | 'ACTIVITY_RECOGNITION'
2090
- | 'ANSWER_PHONE_CALLS'
2091
- | 'READ_PHONE_NUMBERS'
2092
- | 'UWB_RANGING'
2093
- | 'POST_NOTIFICATIONS'
2094
- | 'NEARBY_WIFI_DEVICES']: Permission;
2095
- };
2096
- new (): PermissionsAndroidStatic;
2097
  checkPermission(permission: Permission): Promise<boolean>;
2098
  check(permission: Permission): Promise<boolean>;
2099
  requestPermission(
2100
  permission: Permission,
@@ -2102,349 +4321,868 @@
2102
  ): Promise<boolean>;
2103
  request(
2104
  permission: Permission,
2105
  rationale?: Rationale
2106
- ): Promise<PermissionStatus>;
2107
  requestMultiple(
2108
  permissions: Array<Permission>
2109
- ): Promise<{[key in Permission]: PermissionStatus}>;
2110
  }
 
 
 
2111
- export declare type PermissionStatus = 'granted' | 'denied' | 'never_ask_again';
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2112
- export declare interface PerspectiveTransform {
 
2113
- perspective: AnimatableNumericValue;
 
 
 
2114
  }
2115
- export declare const PixelRatio: PixelRatioStatic;
2116
- export declare interface PixelRatioStatic {
2117
- get(): number;
2118
- getFontScale(): number;
2119
- getPixelSizeForLayoutSize(layoutSize: number): number;
2120
- roundToNearestPixel(layoutSize: number): number;
2121
- startDetecting(): void;
2122
- }
2123
- export declare type Platform =
2124
- | PlatformIOSStatic
2125
- | PlatformAndroidStatic
2126
- | PlatformWindowsOSStatic
2127
- | PlatformMacOSStatic
2128
- | PlatformWebStatic;
2129
- export declare const Platform: Platform;
 
2130
- export declare interface PlatformAndroidStatic extends PlatformStatic {
 
2131
- constants: PlatformConstants & {
 
2132
- Version: number;
2133
- Release: string;
2134
- Serial: string;
2135
- Fingerprint: string;
2136
- Model: string;
2137
- Brand: string;
2138
- Manufacturer: string;
2139
- ServerHost?: string | undefined;
2140
- uiMode: 'car' | 'desk' | 'normal' | 'tv' | 'watch' | 'unknown';
2141
- };
2142
- OS: 'android';
2143
- Version: number;
2144
- }
2145
- export declare function PlatformColor(...colors: string[]): OpaqueColorValue;
 
2146
- export declare type PlatformConstants = {
2147
- isTesting: boolean;
2148
- isDisableAnimations?: boolean | undefined;
2149
- reactNativeVersion: {
2150
- major: number;
2151
- minor: number;
2152
- patch: number;
2153
- prerelease?: string | null | undefined;
2154
- };
2155
- };
2156
- export declare interface PlatformIOSStatic extends PlatformStatic {
2157
- constants: PlatformConstants & {
2158
- forceTouchAvailable: boolean;
2159
- interfaceIdiom: string;
2160
- osVersion: string;
2161
- systemName: string;
2162
- isMacCatalyst?: boolean | undefined;
2163
- };
2164
- OS: 'ios';
2165
- isPad: boolean;
2166
- isTV: boolean;
2167
- isVision: boolean;
2168
- isMacCatalyst?: boolean | undefined;
2169
- Version: string;
2170
- }
2171
- export declare interface PlatformMacOSStatic extends PlatformStatic {
2172
- OS: 'macos';
2173
- Version: string;
2174
- constants: PlatformConstants & {
2175
- osVersion: string;
2176
- };
2177
- }
2178
  export declare type PlatformOSType =
2179
  | 'ios'
2180
  | 'android'
2181
  | 'macos'
2182
  | 'windows'
2183
  | 'web'
2184
  | 'native';
 
2185
- export declare interface PlatformStatic {
2186
- isTV: boolean;
2187
- isTesting: boolean;
2188
- Version: number | string;
2189
- constants: PlatformConstants;
2190
- select<T>(
2191
- specifics:
2192
- | ({[platform in PlatformOSType]?: T} & {default: T})
2193
- | {[platform in PlatformOSType]: T}
2194
- ): T;
2195
- select<T>(specifics: {[platform in PlatformOSType]?: T}): T | undefined;
2196
- }
2197
- export declare interface PlatformWebStatic extends PlatformStatic {
2198
- OS: 'web';
2199
- }
2200
- export declare interface PlatformWindowsOSStatic extends PlatformStatic {
2201
- OS: 'windows';
2202
- Version: number;
2203
- constants: PlatformConstants & {
2204
- osVersion: number;
2205
- };
2206
- }
 
2207
  declare type PointerEvent_2 = NativeSyntheticEvent<NativePointerEvent>;
 
2208
- export {PointerEvent_2 as PointerEvent};
 
2209
- export declare interface PointerEvents {
2210
  onPointerEnter?: ((event: PointerEvent_2) => void) | undefined;
2211
  onPointerEnterCapture?: ((event: PointerEvent_2) => void) | undefined;
2212
  onPointerLeave?: ((event: PointerEvent_2) => void) | undefined;
2213
  onPointerLeaveCapture?: ((event: PointerEvent_2) => void) | undefined;
2214
  onPointerMove?: ((event: PointerEvent_2) => void) | undefined;
2215
  onPointerMoveCapture?: ((event: PointerEvent_2) => void) | undefined;
2216
- onPointerCancel?: ((event: PointerEvent_2) => void) | undefined;
2217
- onPointerCancelCapture?: ((event: PointerEvent_2) => void) | undefined;
2218
- onPointerDown?: ((event: PointerEvent_2) => void) | undefined;
2219
- onPointerDownCapture?: ((event: PointerEvent_2) => void) | undefined;
2220
- onPointerUp?: ((event: PointerEvent_2) => void) | undefined;
2221
- onPointerUpCapture?: ((event: PointerEvent_2) => void) | undefined;
 
 
 
 
 
 
 
 
2222
- }
 
 
 
 
 
 
 
2223
- export declare interface PointProp {
2224
  x: number;
2225
  y: number;
 
 
 
 
 
2226
- }
 
2227
- export declare type PresentLocalNotificationDetails = {
2228
  alertBody: string;
2229
- alertAction: string;
2230
- alertTitle?: string | undefined;
2231
- soundName?: string | undefined;
2232
- category?: string | undefined;
2233
- userInfo?: Object | undefined;
2234
- applicationIconBadgeNumber?: number | undefined;
 
 
2235
  };
 
2236
- export declare const Pressable: React_2.ForwardRefExoticComponent<
2237
- PressableProps & React_2.RefAttributes<View>
 
 
2238
- >;
 
 
2239
- export declare interface PressableAndroidRippleConfig {
2240
- color?: null | ColorValue | undefined;
2241
- borderless?: null | boolean | undefined;
2242
- radius?: null | number | undefined;
2243
- foreground?: null | boolean | undefined;
 
 
 
2244
  }
 
2245
- export declare interface PressableProps
 
 
2246
- extends AccessibilityProps,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2247
- Omit<ViewProps, 'children' | 'style' | 'hitSlop'> {
 
2248
- onHoverIn?: null | ((event: MouseEvent_2) => void) | undefined;
 
2249
- onHoverOut?: null | ((event: MouseEvent_2) => void) | undefined;
2250
- onPress?: null | ((event: GestureResponderEvent) => void) | undefined;
2251
- onPressIn?: null | ((event: GestureResponderEvent) => void) | undefined;
2252
- onPressOut?: null | ((event: GestureResponderEvent) => void) | undefined;
2253
- onLongPress?: null | ((event: GestureResponderEvent) => void) | undefined;
2254
- onBlur?:
2255
- | null
2256
- | ((event: NativeSyntheticEvent<TargetedEvent>) => void)
 
 
 
 
 
 
 
 
 
 
 
2257
- | undefined;
 
2258
- onFocus?:
2259
- | null
2260
- | ((event: NativeSyntheticEvent<TargetedEvent>) => void)
 
 
 
 
 
 
 
 
 
 
 
2261
- | undefined;
 
 
 
 
 
 
2262
  children?:
2263
- | React_2.ReactNode
2264
- | ((state: PressableStateCallbackType) => React_2.ReactNode)
2265
- | undefined;
2266
- cancelable?: null | boolean | undefined;
2267
- delayHoverIn?: number | null | undefined;
 
2268
- delayHoverOut?: number | null | undefined;
 
2269
- delayLongPress?: null | number | undefined;
 
2270
- disabled?: null | boolean | undefined;
 
2271
- hitSlop?: null | Insets | number | undefined;
 
2272
- pressRetentionOffset?: null | Insets | number | undefined;
 
 
 
2273
- android_disableSound?: null | boolean | undefined;
 
2274
- android_ripple?: null | PressableAndroidRippleConfig | undefined;
 
 
 
2275
- testOnly_pressed?: null | boolean | undefined;
 
 
 
 
 
 
 
2276
  style?:
2277
- | StyleProp<ViewStyle>
2278
- | ((state: PressableStateCallbackType) => StyleProp<ViewStyle>)
2279
- | undefined;
2280
- unstable_pressDelay?: number | undefined;
2281
- }
2282
- export declare interface PressableStateCallbackType {
2283
- readonly pressed: boolean;
2284
- }
2285
- export declare function processColor(
2286
- color?: number | ColorValue
2287
- ): ProcessedColorValue | null | undefined;
2288
- export declare type ProcessedColorValue = number | OpaqueColorValue;
2289
- export declare class ProgressBarAndroid extends ProgressBarAndroidBase {}
2290
- export declare const ProgressBarAndroidBase: Constructor<NativeMethods> &
2291
- typeof ProgressBarAndroidComponent;
2292
- export declare class ProgressBarAndroidComponent extends React_2.Component<ProgressBarAndroidProps> {}
2293
- export declare type ProgressBarAndroidProperties = ProgressBarAndroidProps;
2294
- export declare interface ProgressBarAndroidProps extends ViewProps {
2295
- styleAttr?:
2296
- | 'Horizontal'
2297
- | 'Normal'
2298
- | 'Small'
2299
- | 'Large'
2300
- | 'Inverse'
2301
- | 'SmallInverse'
2302
- | 'LargeInverse'
2303
- | undefined;
2304
- indeterminate?: boolean | undefined;
2305
- progress?: number | undefined;
2306
- animating?: boolean | undefined;
2307
- color?: ColorValue | undefined;
2308
  testID?: string | undefined;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2309
- }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2310
  export declare type PromiseTask = {
2311
  name: string;
2312
- gen: () => Promise<any>;
2313
  };
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2314
- export declare interface PushNotification {
2315
- getMessage(): string | Object;
 
2316
- getSound(): string;
 
2317
- getCategory(): string;
 
2318
- getAlert(): string | Object;
 
2319
- getContentAvailable(): number;
 
2320
- getBadgeCount(): number;
 
2321
- getData(): Object;
 
2322
- getThreadId(): string;
 
2323
  finish(result: string): void;
2324
  }
 
2325
- export declare type PushNotificationEventName =
2326
- | 'notification'
 
2327
- | 'localNotification'
 
2328
- | 'register'
 
2329
- | 'registrationError';
2330
- export declare const PushNotificationIOS: PushNotificationIOSStatic;
2331
- export declare type PushNotificationIOS = PushNotificationIOSStatic;
2332
- export declare interface PushNotificationIOSStatic {
2333
- presentLocalNotification(details: PresentLocalNotificationDetails): void;
2334
- scheduleLocalNotification(details: ScheduleLocalNotificationDetails): void;
2335
- cancelAllLocalNotifications(): void;
2336
- removeAllDeliveredNotifications(): void;
2337
- getDeliveredNotifications(callback: (notifications: Object[]) => void): void;
2338
- removeDeliveredNotifications(identifiers: string[]): void;
2339
- cancelLocalNotifications(userInfo: Object): void;
2340
- setApplicationIconBadgeNumber(number: number): void;
2341
- getApplicationIconBadgeNumber(callback: (badge: number) => void): void;
2342
- getScheduledLocalNotifications(
2343
- callback: (notifications: ScheduleLocalNotificationDetails[]) => void
2344
  ): void;
2345
- addEventListener(
2346
- type: 'notification' | 'localNotification',
2347
- handler: (notification: PushNotification) => void
2348
  ): void;
2349
- addEventListener(
 
2350
- type: 'register',
2351
- handler: (deviceToken: string) => void
2352
  ): void;
 
 
 
 
 
2353
- addEventListener(
2354
- type: 'registrationError',
2355
- handler: (error: {message: string; code: number; details: any}) => void
2356
- ): void;
2357
- removeEventListener(
2358
  type: PushNotificationEventName,
2359
- handler:
2360
- | ((notification: PushNotification) => void)
2361
- | ((deviceToken: string) => void)
2362
- | ((error: {message: string; code: number; details: any}) => void)
2363
  ): void;
2364
- requestPermissions(permissions?: PushNotificationPermissions[]): void;
2365
- requestPermissions(
2366
  permissions?: PushNotificationPermissions
2367
- ): Promise<PushNotificationPermissions>;
 
 
 
 
2368
- abandonPermissions(): void;
2369
- checkPermissions(
2370
  callback: (permissions: PushNotificationPermissions) => void
2371
  ): void;
2372
- getInitialNotification(): Promise<PushNotification | null>;
 
 
 
 
2373
- FetchResult: FetchResult;
 
 
 
 
 
 
 
 
2374
  }
 
2375
- export declare interface PushNotificationPermissions {
 
 
 
2376
- alert?: boolean | undefined;
2377
- badge?: boolean | undefined;
2378
- sound?: boolean | undefined;
2379
- }
 
2380
- export declare interface Rationale {
2381
  title: string;
2382
  message: string;
2383
- buttonPositive: string;
2384
- buttonNegative?: string | undefined;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2385
- buttonNeutral?: string | undefined;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2386
  }
2387
- export declare type RCTNativeAppEventEmitter = DeviceEventEmitterStatic;
2388
- export declare interface RecursiveArray<T>
2389
- extends Array<T | ReadonlyArray<T> | RecursiveArray<T>> {}
2390
- export declare class RefreshControl extends RefreshControlBase {
2391
- static SIZE: Object; // Undocumented
2392
- }
2393
- export declare const RefreshControlBase: Constructor<NativeMethods> &
2394
- typeof RefreshControlComponent;
2395
- export declare class RefreshControlComponent extends React_2.Component<RefreshControlProps> {}
2396
- export declare type RefreshControlProperties = RefreshControlProps;
2397
- export declare type RefreshControlPropertiesAndroid =
2398
- RefreshControlPropsAndroid;
2399
- export declare type RefreshControlPropertiesIOS = RefreshControlPropsIOS;
2400
- export declare interface RefreshControlProps
2401
- extends RefreshControlPropsIOS,
2402
- RefreshControlPropsAndroid {
2403
- onRefresh?: (() => void) | undefined;
 
2404
  refreshing: boolean;
 
2405
  progressViewOffset?: number | undefined;
 
 
 
 
 
 
 
 
 
 
2406
- }
 
 
 
 
 
 
 
 
 
2407
- export declare interface RefreshControlPropsAndroid extends ViewProps {
2408
- colors?: ColorValue[] | undefined;
2409
  enabled?: boolean | undefined;
 
 
 
2410
  progressBackgroundColor?: ColorValue | undefined;
 
2411
- size?: number | undefined;
2412
- }
 
2413
- export declare interface RefreshControlPropsIOS extends ViewProps {
2414
  tintColor?: ColorValue | undefined;
2415
- title?: string | undefined;
2416
  titleColor?: ColorValue | undefined;
 
 
2417
- }
 
2418
- export declare type RegisterCallableModule = (
2419
  name: string,
2420
- moduleOrFactory: Module | (() => Module)
2421
  ) => void;
 
 
 
 
 
2422
- export declare const registerCallableModule: RegisterCallableModule;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2423
- export declare type RegisteredStyle<T> = number & {__registeredStyleBrand: T};
 
2424
- export declare function requireNativeComponent<T>(
2425
- viewName: string
2426
- ): HostComponent<T>;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2427
- export declare type ReturnKeyType = 'done' | 'go' | 'next' | 'search' | 'send';
 
 
 
2428
- export declare type ReturnKeyTypeAndroid = 'none' | 'previous';
 
 
 
2429
- export declare type ReturnKeyTypeIOS =
2430
  | 'default'
 
2431
  | 'google'
2432
  | 'join'
2433
  | 'route'
2434
- | 'yahoo'
 
 
 
2435
- | 'emergency-call';
 
 
 
 
 
2436
  export declare type ReturnKeyTypeOptions =
2437
  | ReturnKeyType
 
2438
- | ReturnKeyTypeAndroid
 
 
 
2439
- | ReturnKeyTypeIOS;
2440
- export declare interface RippleBackgroundPropType
2441
- extends BaseBackgroundPropType {
2442
- type: 'RippleAndroid';
 
 
2443
- borderless: boolean;
 
2444
- color?: number | null | undefined;
 
2445
- }
 
 
 
 
 
 
 
 
2446
- export declare type Role =
2447
  | 'alert'
2448
  | 'alertdialog'
2449
  | 'application'
2450
  | 'article'
@@ -2508,528 +5246,1342 @@
2508
  | 'tooltip'
2509
  | 'tree'
2510
  | 'treegrid'
2511
  | 'treeitem';
 
2512
- export declare type RootTag = number;
2513
- export declare const RootTagContext: React_2.Context<RootTag>;
2514
- export declare type RootViewStyleProvider = (appParameters: any) => ViewStyle;
2515
- export declare interface RotateTransform {
2516
- rotate: AnimatableStringValue;
2517
- }
2518
- export declare interface RotateXTransform {
2519
- rotateX: AnimatableStringValue;
2520
- }
2521
- export declare interface RotateYTransform {
2522
- rotateY: AnimatableStringValue;
2523
- }
2524
- export declare interface RotateZTransform {
2525
- rotateZ: AnimatableStringValue;
2526
- }
2527
- export declare type Runnable = (appParameters: any) => void;
2528
- export declare class SafeAreaView extends SafeAreaViewBase {}
2529
- export declare const SafeAreaViewBase: Constructor<NativeMethods> &
2530
- typeof SafeAreaViewComponent;
2531
- export declare class SafeAreaViewComponent extends React_2.Component<ViewProps> {}
2532
- export declare interface ScaledSize {
2533
- width: number;
2534
- height: number;
2535
- scale: number;
2536
- fontScale: number;
2537
- }
2538
- export declare interface ScaleTransform {
2539
- scale: AnimatableNumericValue;
2540
- }
2541
- export declare interface ScaleXTransform {
2542
- scaleX: AnimatableNumericValue;
2543
- }
2544
- export declare interface ScaleYTransform {
2545
- scaleY: AnimatableNumericValue;
2546
- }
2547
- export declare type ScheduleLocalNotificationDetails = {
2548
- alertAction?: string | undefined;
2549
- alertBody?: string | undefined;
2550
- alertTitle?: string | undefined;
2551
- applicationIconBadgeNumber?: number | undefined;
2552
- category?: string | undefined;
2553
- fireDate?: number | string | undefined;
2554
- isSilent?: boolean | undefined;
2555
- repeatInterval?:
2556
- | 'year'
2557
- | 'month'
2558
- | 'week'
2559
- | 'day'
2560
- | 'hour'
2561
- | 'minute'
2562
- | undefined;
2563
- soundName?: string | undefined;
2564
- userInfo?: Object | undefined;
2565
  };
2566
- export declare interface ScrollResponderEvent
2567
- extends NativeSyntheticEvent<NativeTouchEvent> {}
2568
- export declare interface ScrollResponderMixin extends SubscribableMixin {
2569
- scrollResponderHandleScrollShouldSetResponder(): boolean;
2570
- scrollResponderHandleStartShouldSetResponder(): boolean;
2571
- scrollResponderHandleStartShouldSetResponderCapture(
2572
- e: ScrollResponderEvent
2573
- ): boolean;
2574
- scrollResponderHandleResponderReject(): any;
2575
- scrollResponderHandleTerminationRequest(): boolean;
2576
- scrollResponderHandleTouchEnd(e: ScrollResponderEvent): void;
2577
- scrollResponderHandleResponderRelease(e: ScrollResponderEvent): void;
2578
- scrollResponderHandleScroll(e: ScrollResponderEvent): void;
2579
- scrollResponderHandleResponderGrant(e: ScrollResponderEvent): void;
2580
- scrollResponderHandleScrollBeginDrag(e: ScrollResponderEvent): void;
2581
- scrollResponderHandleScrollEndDrag(e: ScrollResponderEvent): void;
2582
- scrollResponderHandleMomentumScrollBegin(e: ScrollResponderEvent): void;
2583
- scrollResponderHandleMomentumScrollEnd(e: ScrollResponderEvent): void;
2584
- scrollResponderHandleTouchStart(e: ScrollResponderEvent): void;
2585
- scrollResponderHandleTouchMove(e: ScrollResponderEvent): void;
2586
- scrollResponderIsAnimating(): boolean;
2587
- scrollResponderGetScrollableNode(): any;
2588
- scrollResponderScrollTo(
2589
- x?:
2590
- | number
2591
- | {
2592
- x?: number | undefined;
2593
- y?: number | undefined;
2594
- animated?: boolean | undefined;
2595
- },
2596
- y?: number,
2597
- animated?: boolean
2598
- ): void;
2599
- scrollResponderZoomTo(
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2600
  rect: {
2601
  x: number;
2602
  y: number;
2603
  width: number;
2604
  height: number;
2605
- animated?: boolean | undefined;
2606
  },
2607
- animated?: boolean // deprecated, put this inside the rect argument instead
2608
- ): void;
2609
- scrollResponderScrollNativeHandleToKeyboard(
2610
- nodeHandle: any,
2611
- additionalOffset?: number,
2612
- preventNegativeScrollOffset?: boolean
2613
- ): void;
2614
- scrollResponderInputMeasureAndScrollToKeyboard(
2615
- left: number,
2616
- top: number,
2617
- width: number,
2618
- height: number
2619
- ): void;
2620
- scrollResponderTextInputFocusError(e: ScrollResponderEvent): void;
2621
- componentWillMount(): void;
2622
- scrollResponderKeyboardWillShow(e: ScrollResponderEvent): void;
2623
- scrollResponderKeyboardWillHide(e: ScrollResponderEvent): void;
2624
- scrollResponderKeyboardDidShow(e: ScrollResponderEvent): void;
2625
- scrollResponderKeyboardDidHide(e: ScrollResponderEvent): void;
 
2626
  }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2627
- export declare class ScrollView extends ScrollViewBase {
2628
- scrollTo(
2629
- y?:
2630
- | number
2631
- | {
2632
- x?: number | undefined;
2633
- y?: number | undefined;
2634
- animated?: boolean | undefined;
2635
- },
2636
- deprecatedX?: number,
2637
- deprecatedAnimated?: boolean
2638
- ): void;
2639
- scrollToEnd(options?: {animated?: boolean | undefined}): void;
2640
- flashScrollIndicators(): void;
2641
- getScrollResponder(): ScrollResponderMixin;
2642
- getScrollableNode(): any;
2643
- getInnerViewNode(): any;
2644
- scrollWithoutAnimationTo?: ((y: number, x: number) => void) | undefined;
2645
- setNativeProps(nativeProps: object): void;
2646
  }
2647
- export declare const _ScrollView: typeof ScrollView;
2648
- export declare const ScrollViewBase: Constructor<ScrollResponderMixin> &
2649
- typeof ScrollViewComponent;
2650
- export declare class ScrollViewComponent extends React_2.Component<ScrollViewProps> {}
2651
- export declare type ScrollViewProperties = ScrollViewProps;
2652
- export declare type ScrollViewPropertiesAndroid = ScrollViewPropsAndroid;
2653
- export declare type ScrollViewPropertiesIOS = ScrollViewPropsIOS;
2654
- export declare interface ScrollViewProps
2655
- extends ViewProps,
2656
- ScrollViewPropsIOS,
2657
- ScrollViewPropsAndroid,
2658
- Touchable {
2659
- contentContainerStyle?: StyleProp<ViewStyle> | undefined;
2660
- decelerationRate?: 'fast' | 'normal' | number | undefined;
2661
- horizontal?: boolean | null | undefined;
2662
- invertStickyHeaders?: boolean | undefined;
2663
- keyboardDismissMode?: 'none' | 'interactive' | 'on-drag' | undefined;
2664
- keyboardShouldPersistTaps?:
2665
- | boolean
2666
- | 'always'
2667
- | 'never'
2668
- | 'handled'
2669
- | undefined;
2670
- onContentSizeChange?: ((w: number, h: number) => void) | undefined;
2671
- onScroll?:
2672
- | ((event: NativeSyntheticEvent<NativeScrollEvent>) => void)
2673
- | undefined;
2674
- onScrollBeginDrag?:
2675
- | ((event: NativeSyntheticEvent<NativeScrollEvent>) => void)
2676
- | undefined;
2677
- onScrollEndDrag?:
2678
- | ((event: NativeSyntheticEvent<NativeScrollEvent>) => void)
2679
- | undefined;
2680
- onMomentumScrollEnd?:
2681
- | ((event: NativeSyntheticEvent<NativeScrollEvent>) => void)
2682
- | undefined;
2683
- onMomentumScrollBegin?:
2684
- | ((event: NativeSyntheticEvent<NativeScrollEvent>) => void)
2685
- | undefined;
2686
- pagingEnabled?: boolean | undefined;
2687
- scrollEnabled?: boolean | undefined; // true
2688
- removeClippedSubviews?: boolean | undefined;
2689
- showsHorizontalScrollIndicator?: boolean | undefined;
2690
- showsVerticalScrollIndicator?: boolean | undefined;
2691
- stickyHeaderHiddenOnScroll?: boolean | undefined;
2692
- style?: StyleProp<ViewStyle> | undefined;
2693
- refreshControl?: React_2.ReactElement<RefreshControlProps> | undefined;
2694
- snapToInterval?: number | undefined;
2695
- snapToOffsets?: number[] | undefined;
2696
- snapToStart?: boolean | undefined;
2697
- snapToEnd?: boolean | undefined;
2698
- stickyHeaderIndices?: number[] | undefined;
2699
- disableIntervalMomentum?: boolean | undefined;
2700
- disableScrollViewPanResponder?: boolean | undefined;
2701
- StickyHeaderComponent?: React_2.ComponentType<any> | undefined;
2702
- }
2703
- export declare interface ScrollViewPropsAndroid {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2704
  endFillColor?: ColorValue | undefined;
 
2705
  scrollPerfTag?: string | undefined;
 
2706
- overScrollMode?: 'auto' | 'always' | 'never' | undefined;
2707
- nestedScrollEnabled?: boolean | undefined;
2708
- fadingEdgeLength?: number | undefined;
2709
  persistentScrollbar?: boolean | undefined;
 
 
2710
- }
 
2711
- export declare interface ScrollViewPropsIOS {
2712
- alwaysBounceHorizontal?: boolean | undefined;
2713
- alwaysBounceVertical?: boolean | undefined;
2714
- automaticallyAdjustContentInsets?: boolean | undefined; // true
 
2715
  automaticallyAdjustKeyboardInsets?: boolean | undefined;
 
2716
  automaticallyAdjustsScrollIndicatorInsets?: boolean | undefined;
 
 
 
2717
  bounces?: boolean | undefined;
 
 
 
2718
  bouncesZoom?: boolean | undefined;
 
 
 
2719
- canCancelContentTouches?: boolean | undefined;
 
2720
  centerContent?: boolean | undefined;
2721
- contentInset?: Insets | undefined; // zeros
2722
- contentOffset?: PointProp | undefined; // zeros
2723
- contentInsetAdjustmentBehavior?:
2724
- | 'automatic'
2725
- | 'scrollableAxes'
2726
- | 'never'
2727
- | 'always'
2728
- | undefined;
2729
  directionalLockEnabled?: boolean | undefined;
2730
- indicatorStyle?: 'default' | 'black' | 'white' | undefined;
2731
- maintainVisibleContentPosition?:
2732
- | null
2733
- | {
2734
- autoscrollToTopThreshold?: number | null | undefined;
2735
- minIndexForVisible: number;
2736
- }
2737
- | undefined;
2738
  maximumZoomScale?: number | undefined;
 
2739
  minimumZoomScale?: number | undefined;
2740
- onScrollAnimationEnd?: (() => void) | undefined;
2741
  pinchGestureEnabled?: boolean | undefined;
2742
- scrollEventThrottle?: number | undefined;
2743
- scrollIndicatorInsets?: Insets | undefined; //zeroes
 
2744
  scrollToOverflowEnabled?: boolean | undefined;
 
2745
  scrollsToTop?: boolean | undefined;
2746
- snapToAlignment?: 'start' | 'center' | 'end' | undefined;
2747
- onScrollToTop?:
2748
- | ((event: NativeSyntheticEvent<NativeScrollEvent>) => void)
 
2749
- | undefined;
 
2750
  zoomScale?: number | undefined;
 
 
 
 
 
 
 
 
 
 
2751
  }
 
2752
- export declare interface SectionBase<ItemT, SectionT = DefaultSectionT> {
 
 
2753
- data: ReadonlyArray<ItemT>;
 
 
 
2754
- key?: string | undefined;
 
 
 
 
 
 
 
 
2755
- renderItem?: SectionListRenderItem<ItemT, SectionT> | undefined;
2756
- ItemSeparatorComponent?: React_2.ComponentType<any> | null | undefined;
2757
- keyExtractor?: ((item: ItemT, index: number) => string) | undefined;
2758
- }
2759
  export declare class SectionList<
2760
- ItemT = any,
2761
  SectionT = DefaultSectionT,
2762
- > extends SectionListComponent<SectionListProps<ItemT, SectionT>> {}
2763
- export declare abstract class SectionListComponent<
2764
- Props,
2765
- > extends React_2.Component<Props> {
2766
- scrollToLocation(params: SectionListScrollParams): void;
2767
  recordInteraction(): void;
2768
  flashScrollIndicators(): void;
2769
- getScrollResponder(): ScrollView | undefined;
2770
- getScrollableNode(): NodeHandle | undefined;
 
 
2771
  }
2772
- export declare type SectionListData<
2773
- ItemT,
2774
- SectionT = DefaultSectionT,
2775
- > = SectionBase<ItemT, SectionT> & SectionT;
2776
- export declare type SectionListProperties<ItemT> = SectionListProps<ItemT>;
2777
- export declare interface SectionListProps<ItemT, SectionT = DefaultSectionT>
2778
- extends VirtualizedListWithoutPreConfiguredProps<ItemT> {
2779
- SectionSeparatorComponent?:
2780
- | React_2.ComponentType<any>
2781
- | React_2.ReactElement
2782
- | null
2783
- | undefined;
2784
- extraData?: any | undefined;
2785
- getItemLayout?:
2786
- | ((
2787
- data: SectionListData<ItemT, SectionT>[] | null,
2788
- index: number
2789
- ) => {length: number; offset: number; index: number})
2790
- | undefined;
2791
- initialNumToRender?: number | undefined;
2792
- inverted?: boolean | null | undefined;
2793
- keyExtractor?: ((item: ItemT, index: number) => string) | undefined;
2794
- onEndReached?: ((info: {distanceFromEnd: number}) => void) | null | undefined;
2795
- onEndReachedThreshold?: number | null | undefined;
2796
- onRefresh?: (() => void) | null | undefined;
2797
- onScrollToIndexFailed?:
2798
- | ((info: {
2799
- index: number;
2800
- highestMeasuredFrameIndex: number;
2801
- averageItemLength: number;
2802
- }) => void)
2803
- | undefined;
2804
- refreshing?: boolean | null | undefined;
2805
- renderItem?: SectionListRenderItem<ItemT, SectionT> | undefined;
2806
- renderSectionHeader?:
2807
- | ((info: {
2808
- section: SectionListData<ItemT, SectionT>;
 
 
 
2809
- }) => React_2.ReactElement | null)
2810
- | undefined;
2811
- renderSectionFooter?:
2812
- | ((info: {
2813
- section: SectionListData<ItemT, SectionT>;
 
 
 
 
2814
- }) => React_2.ReactElement | null)
2815
- | undefined;
2816
- sections: ReadonlyArray<SectionListData<ItemT, SectionT>>;
2817
- renderScrollComponent?:
2818
- | ((props: ScrollViewProps) => React_2.ReactElement<ScrollViewProps>)
2819
- | undefined;
2820
- removeClippedSubviews?: boolean | undefined;
2821
- stickySectionHeadersEnabled?: boolean | undefined;
2822
- legacyImplementation?: boolean | undefined;
2823
- }
2824
  export declare type SectionListRenderItem<ItemT, SectionT = DefaultSectionT> = (
2825
  info: SectionListRenderItemInfo<ItemT, SectionT>
2826
- ) => React_2.ReactElement | null;
 
2827
- export declare interface SectionListRenderItemInfo<
2828
  ItemT,
2829
  SectionT = DefaultSectionT,
 
2830
- > extends ListRenderItemInfo<ItemT> {
 
2831
- section: SectionListData<ItemT, SectionT>;
2832
- }
 
 
 
 
2833
- export declare interface SectionListScrollParams {
2834
- animated?: boolean | undefined;
2835
- itemIndex: number;
 
 
 
 
2836
- sectionIndex: number;
 
 
 
 
 
 
 
 
 
 
 
 
 
2837
- viewOffset?: number | undefined;
2838
- viewPosition?: number | undefined;
2839
- }
2840
- export declare interface SectionListStatic<ItemT, SectionT = DefaultSectionT>
2841
- extends React_2.ComponentClass<SectionListProps<ItemT, SectionT>> {
 
 
2842
- scrollToLocation?(params: SectionListScrollParams): void;
2843
- }
2844
- declare function setEnabled(_doEnable: boolean): void;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2845
- export declare const Settings: SettingsStatic;
 
2846
- export declare type Settings = SettingsStatic;
 
2847
- export declare interface SettingsStatic {
2848
  get(key: string): any;
2849
  set(settings: Object): void;
2850
  watchKeys(keys: string | Array<string>, callback: () => void): number;
2851
  clearWatch(watchId: number): void;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2852
  }
2853
- export declare interface ShadowStyleIOS {
2854
- shadowColor?: ColorValue | undefined;
2855
- shadowOffset?: Readonly<{width: number; height: number}> | undefined;
2856
- shadowOpacity?: AnimatableNumericValue | undefined;
2857
- shadowRadius?: number | undefined;
2858
- }
2859
- export declare const Share: ShareStatic;
2860
- export declare type Share = ShareStatic;
2861
  export declare type ShareAction = {
2862
  action: 'sharedAction' | 'dismissedAction';
2863
- activityType?: string | null | undefined;
2864
  };
 
 
 
 
 
 
 
 
2865
- export declare interface ShareActionSheetIOSOptions {
2866
  message?: string | undefined;
2867
  url?: string | undefined;
2868
  subject?: string | undefined;
2869
  anchor?: number | undefined;
 
 
 
2870
- excludedActivityTypes?: string[] | undefined;
 
2871
- }
 
2872
  export declare type ShareContent =
2873
  | {
2874
- title?: string | undefined;
2875
  url: string;
2876
- message?: string | undefined;
2877
  }
2878
  | {
2879
- title?: string | undefined;
2880
- url?: string | undefined;
2881
  message: string;
2882
  };
 
2883
  export declare type ShareOptions = {
2884
- dialogTitle?: string | undefined;
2885
- excludedActivityTypes?: Array<string> | undefined;
2886
- tintColor?: ColorValue | undefined;
2887
- subject?: string | undefined;
2888
- anchor?: number | undefined;
2889
  };
2890
- export declare interface ShareStatic {
2891
- share(content: ShareContent, options?: ShareOptions): Promise<ShareAction>;
2892
- sharedAction: 'sharedAction';
2893
- dismissedAction: 'dismissedAction';
2894
- }
2895
  export declare type SimpleTask = {
2896
  name: string;
2897
- gen: () => void;
2898
  };
 
2899
- export declare interface SkewXTransform {
 
 
 
 
 
2900
- skewX: AnimatableStringValue;
 
 
 
 
 
 
2901
  }
 
2902
- export declare interface SkewYTransform {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2903
- skewY: AnimatableStringValue;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2904
  }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2905
- export declare class StatusBar extends React_2.Component<StatusBarProps> {
2906
- static currentHeight?: number | undefined;
2907
- static setHidden: (hidden: boolean, animation?: StatusBarAnimation) => void;
2908
- static setBarStyle: (style: StatusBarStyle, animated?: boolean) => void;
2909
- static setNetworkActivityIndicatorVisible: (visible: boolean) => void;
2910
- static setBackgroundColor: (color: ColorValue, animated?: boolean) => void;
2911
- static setTranslucent: (translucent: boolean) => void;
2912
- static pushStackEntry: (props: StatusBarProps) => StatusBarProps;
2913
- static popStackEntry: (entry: StatusBarProps) => void;
2914
- static replaceStackEntry: (
2915
- entry: StatusBarProps,
2916
  props: StatusBarProps
2917
- ) => StatusBarProps;
 
 
 
 
2918
  }
2919
- export declare type StatusBarAnimation = 'none' | 'fade' | 'slide';
2920
- export declare type StatusBarProperties = StatusBarProps;
 
 
 
 
2921
- export declare type StatusBarPropertiesAndroid = StatusBarPropsAndroid;
 
 
2922
- export declare type StatusBarPropertiesIOS = StatusBarPropsIOS;
2923
- export declare interface StatusBarProps
2924
- extends StatusBarPropsIOS,
2925
- StatusBarPropsAndroid {
2926
- animated?: boolean | undefined;
2927
- barStyle?: null | StatusBarStyle | undefined;
2928
  hidden?: boolean | undefined;
 
 
 
 
2929
- }
 
2930
- export declare interface StatusBarPropsAndroid {
 
 
 
 
 
 
 
 
 
2931
  backgroundColor?: ColorValue | undefined;
 
2932
  translucent?: boolean | undefined;
2933
- }
 
2934
- export declare interface StatusBarPropsIOS {
2935
  networkActivityIndicatorVisible?: boolean | undefined;
 
2936
- showHideTransition?: null | 'fade' | 'slide' | 'none' | undefined;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2937
- }
2938
- export declare type StatusBarStyle =
2939
- | 'default'
 
 
 
 
 
2940
- | 'light-content'
2941
- | 'dark-content';
2942
  export declare type StyleProp<T> =
 
 
2943
  | T
2944
- | RegisteredStyle<T>
2945
- | RecursiveArray<T | RegisteredStyle<T> | Falsy>
2946
- | Falsy;
 
 
 
2947
- export declare namespace StyleSheet {
 
 
 
 
 
 
2948
- export type NamedStyles<T> = {
2949
- [P in keyof T]: ViewStyle | TextStyle | ImageStyle;
2950
  };
2951
- export function create<T extends NamedStyles<T> | NamedStyles<any>>(
2952
- styles: T & NamedStyles<any>
2953
- ): T;
2954
- export function flatten<T>(
2955
- style?: StyleProp<T>
2956
- ): T extends (infer U)[] ? U : T;
2957
- export function compose<
2958
- T extends ViewStyle | TextStyle | ImageStyle,
2959
- U extends T,
2960
- V extends T,
2961
- >(
2962
- style1: StyleProp<U> | Array<StyleProp<U>>,
2963
- style2: StyleProp<V> | Array<StyleProp<V>>
2964
- ): StyleProp<T>;
2965
- export function setStyleAttributePreprocessor(
2966
- property: string,
2967
- process: (nextProp: any) => any
2968
- ): void;
2969
- const hairlineWidth: number;
2970
- export interface AbsoluteFillStyle {
2971
- position: 'absolute';
2972
- left: 0;
2973
- right: 0;
2974
- top: 0;
2975
- bottom: 0;
2976
- }
2977
- const absoluteFillObject: AbsoluteFillStyle;
2978
- const absoluteFill: RegisteredStyle<AbsoluteFillStyle>;
2979
  }
2980
- export declare interface StyleSheetProperties {
2981
- hairlineWidth: number;
2982
- flatten<T extends string>(style: T): T;
2983
- }
2984
  export declare type SubmitBehavior = 'submit' | 'blurAndSubmit' | 'newline';
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2985
- export declare interface SubscribableMixin {
2986
- addListenerOn(
2987
- eventEmitter: any,
2988
- eventType: string,
2989
- listener: () => any,
 
2990
- context: any
2991
- ): void;
 
2992
- }
 
2993
- export declare class Switch extends SwitchBase {}
2994
- export declare const SwitchBase: Constructor<NativeMethods> &
2995
- typeof SwitchComponent;
 
2996
- export declare interface SwitchChangeEvent
2997
- extends NativeSyntheticEvent<SwitchChangeEventData> {}
 
2998
- export declare interface SwitchChangeEventData extends TargetedEvent {
2999
  value: boolean;
 
3000
- }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3001
- export declare class SwitchComponent extends React_2.Component<SwitchProps> {}
 
 
 
 
3002
- export declare type SwitchProperties = SwitchProps;
 
 
 
 
 
3003
- export declare type SwitchPropertiesIOS = SwitchPropsIOS;
3004
- export declare interface SwitchProps extends SwitchPropsIOS {
 
 
 
3005
  thumbColor?: ColorValue | undefined;
 
3006
  trackColor?:
3007
- | {
3008
- false?: ColorValue | null | undefined;
3009
- true?: ColorValue | null | undefined;
3010
- }
3011
  | undefined;
3012
- disabled?: boolean | undefined;
3013
- onChange?:
3014
- | ((event: SwitchChangeEvent) => Promise<void> | void)
3015
- | null
3016
- | undefined;
3017
- onValueChange?: ((value: boolean) => Promise<void> | void) | null | undefined;
3018
- testID?: string | undefined;
3019
- value?: boolean | undefined;
3020
  ios_backgroundColor?: ColorValue | undefined;
 
 
 
3021
- style?: StyleProp<ViewStyle> | undefined;
3022
- }
 
3023
- export declare interface SwitchPropsIOS extends ViewProps {
3024
  onTintColor?: ColorValue | undefined;
 
3025
  thumbTintColor?: ColorValue | undefined;
 
3026
  tintColor?: ColorValue | undefined;
3027
- }
 
 
 
 
 
 
3028
  export declare namespace Systrace {
3029
  export {
3030
  isEnabled,
3031
- setEnabled,
3032
  beginEvent,
3033
  endEvent,
3034
  beginAsyncEvent,
3035
  endAsyncEvent,
@@ -3037,793 +6589,2322 @@
3037
  EventName,
3038
  EventArgs,
3039
  };
3040
  }
 
3041
- export declare interface TargetedEvent {
3042
  target: number;
3043
- }
 
 
 
 
 
 
 
 
 
3044
- export declare type Task = (taskData: any) => Promise<void>;
 
 
 
3045
- export declare type TaskCanceller = () => void;
 
3046
- export declare type TaskCancelProvider = () => TaskCanceller;
 
3047
  export declare type TaskProvider = () => Task;
 
 
 
 
 
 
 
 
 
 
 
3048
- export declare const _Text: typeof Text_2;
 
3049
- declare class Text_2 extends TextBase {}
3050
  export {Text_2 as Text};
3051
- export declare const TextBase: Constructor<NativeMethods> &
3052
- typeof TextComponent;
3053
- export declare class TextComponent extends React_2.Component<TextProps> {}
3054
- export declare class TextInput extends TextInputBase {
3055
- static State: TextInputState;
3056
- isFocused: () => boolean;
3057
- clear: () => void;
 
 
 
3058
- setSelection: (start: number, end: number) => void;
3059
- }
 
 
 
 
 
3060
- export declare type TextInputAndroidProperties = TextInputAndroidProps;
3061
- export declare interface TextInputAndroidProps {
3062
- cursorColor?: ColorValue | null | undefined;
3063
- selectionHandleColor?: ColorValue | null | undefined;
3064
- importantForAutofill?:
3065
- | 'auto'
3066
- | 'no'
3067
- | 'noExcludeDescendants'
3068
- | 'yes'
3069
- | 'yesExcludeDescendants'
3070
  | undefined;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3071
  disableFullscreenUI?: boolean | undefined;
 
 
 
 
 
3072
  inlineImageLeft?: string | undefined;
 
3073
  inlineImagePadding?: number | undefined;
 
3074
  numberOfLines?: number | undefined;
 
3075
  returnKeyLabel?: string | undefined;
 
 
 
 
 
3076
- textBreakStrategy?: 'simple' | 'highQuality' | 'balanced' | undefined;
 
3077
  underlineColorAndroid?: ColorValue | undefined;
 
 
 
 
 
 
 
 
 
 
3078
- textAlignVertical?: 'auto' | 'top' | 'bottom' | 'center' | undefined;
 
 
 
 
 
 
 
 
 
 
 
 
3079
  showSoftInputOnFocus?: boolean | undefined;
 
3080
- verticalAlign?: 'auto' | 'top' | 'bottom' | 'middle' | undefined;
 
 
3081
- }
 
3082
- export declare const TextInputBase: Constructor<NativeMethods> &
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3083
- Constructor<TimerMixin> &
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3084
- typeof TextInputComponent;
 
 
3085
  export declare type TextInputChangeEvent =
3086
  NativeSyntheticEvent<TextInputChangeEventData>;
 
 
 
 
3087
- export declare interface TextInputChangeEventData extends TargetedEvent {
3088
  eventCount: number;
 
3089
  text: string;
3090
- }
 
 
 
 
 
 
 
3091
- export declare class TextInputComponent extends React_2.Component<TextInputProps> {}
 
 
 
 
 
 
 
 
3092
  export declare type TextInputContentSizeChangeEvent =
3093
  NativeSyntheticEvent<TextInputContentSizeChangeEventData>;
 
3094
- export declare interface TextInputContentSizeChangeEventData {
 
 
 
 
3095
- contentSize: {width: number; height: number};
 
 
3096
- }
 
 
 
 
 
 
 
 
 
 
3097
  export declare type TextInputEndEditingEvent =
3098
  NativeSyntheticEvent<TextInputEndEditingEventData>;
 
3099
- export declare interface TextInputEndEditingEventData {
 
 
 
 
 
 
 
3100
- text: string;
3101
- }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3102
  export declare type TextInputFocusEvent =
3103
  NativeSyntheticEvent<TextInputFocusEventData>;
 
 
 
 
3104
- export declare interface TextInputFocusEventData extends TargetedEvent {
 
 
 
 
3105
- text: string;
3106
- eventCount: number;
 
 
3107
  }
 
3108
- export declare type TextInputIOSProperties = TextInputIOSProps;
3109
- export declare interface TextInputIOSProps {
3110
  disableKeyboardShortcuts?: boolean | undefined;
 
3111
  clearButtonMode?:
3112
- | 'never'
3113
- | 'while-editing'
3114
- | 'unless-editing'
3115
- | 'always'
3116
  | undefined;
 
3117
  clearTextOnFocus?: boolean | undefined;
 
 
3118
- dataDetectorTypes?: DataDetectorTypes | DataDetectorTypes[] | undefined;
 
 
3119
  enablesReturnKeyAutomatically?: boolean | undefined;
 
 
 
 
 
3120
- keyboardAppearance?: 'default' | 'light' | 'dark' | undefined;
 
3121
- passwordRules?: string | null | undefined;
3122
- rejectResponderTermination?: boolean | null | undefined;
 
3123
- selectionState?: DocumentSelectionState | undefined;
 
3124
  spellCheck?: boolean | undefined;
 
 
 
3125
- textContentType?:
3126
- | 'none'
3127
- | 'URL'
3128
- | 'addressCity'
3129
- | 'addressCityAndState'
3130
- | 'addressState'
3131
- | 'countryName'
3132
- | 'creditCardNumber'
3133
- | 'creditCardExpiration'
3134
- | 'creditCardExpirationMonth'
3135
- | 'creditCardExpirationYear'
3136
- | 'creditCardSecurityCode'
3137
- | 'creditCardType'
3138
- | 'creditCardName'
3139
- | 'creditCardGivenName'
3140
- | 'creditCardMiddleName'
3141
- | 'creditCardFamilyName'
3142
- | 'emailAddress'
3143
- | 'familyName'
3144
- | 'fullStreetAddress'
3145
- | 'givenName'
3146
- | 'jobTitle'
3147
- | 'location'
3148
- | 'middleName'
3149
- | 'name'
3150
- | 'namePrefix'
3151
- | 'nameSuffix'
3152
- | 'nickname'
3153
- | 'organizationName'
3154
- | 'postalCode'
3155
- | 'streetAddressLine1'
3156
- | 'streetAddressLine2'
3157
- | 'sublocality'
3158
- | 'telephoneNumber'
3159
- | 'username'
3160
- | 'password'
3161
- | 'newPassword'
3162
- | 'oneTimeCode'
3163
- | 'birthdate'
3164
- | 'birthdateDay'
3165
- | 'birthdateMonth'
3166
- | 'birthdateYear'
3167
- | 'cellularEID'
3168
- | 'cellularIMEI'
3169
- | 'dateTime'
3170
- | 'flightNumber'
3171
- | 'shipmentTrackingNumber'
3172
  | undefined;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3173
  scrollEnabled?: boolean | undefined;
 
 
 
 
 
3174
  lineBreakStrategyIOS?:
3175
- | 'none'
3176
- | 'standard'
3177
- | 'hangul-word'
3178
- | 'push-out'
3179
  | undefined;
 
3180
  lineBreakModeIOS?:
3181
- | 'wordWrapping'
3182
- | 'char'
3183
- | 'clip'
3184
- | 'head'
3185
- | 'middle'
3186
- | 'tail'
3187
  | undefined;
 
3188
  smartInsertDelete?: boolean | undefined;
3189
- }
 
3190
  export declare type TextInputKeyPressEvent =
3191
  NativeSyntheticEvent<TextInputKeyPressEventData>;
3192
- export declare interface TextInputKeyPressEventData {
3193
- key: string;
3194
- }
3195
- export declare type TextInputProperties = TextInputProps;
3196
- export declare interface TextInputProps
3197
- extends ViewProps,
3198
- TextInputIOSProps,
3199
- TextInputAndroidProps,
3200
- AccessibilityProps {
3201
- allowFontScaling?: boolean | undefined;
3202
- autoCapitalize?: 'none' | 'sentences' | 'words' | 'characters' | undefined;
3203
- autoComplete?:
3204
- | 'additional-name'
3205
- | 'address-line1'
3206
- | 'address-line2'
3207
- | 'birthdate-day'
3208
- | 'birthdate-full'
3209
- | 'birthdate-month'
3210
- | 'birthdate-year'
3211
- | 'cc-csc'
3212
- | 'cc-exp'
3213
- | 'cc-exp-day'
3214
- | 'cc-exp-month'
3215
- | 'cc-exp-year'
3216
- | 'cc-number'
3217
- | 'cc-name'
3218
- | 'cc-given-name'
3219
- | 'cc-middle-name'
3220
- | 'cc-family-name'
3221
- | 'cc-type'
3222
- | 'country'
3223
- | 'current-password'
3224
- | 'email'
3225
- | 'family-name'
3226
- | 'gender'
3227
- | 'given-name'
3228
- | 'honorific-prefix'
3229
- | 'honorific-suffix'
3230
- | 'name'
3231
- | 'name-family'
3232
- | 'name-given'
3233
- | 'name-middle'
3234
- | 'name-middle-initial'
3235
- | 'name-prefix'
3236
- | 'name-suffix'
3237
- | 'new-password'
3238
- | 'nickname'
3239
- | 'one-time-code'
3240
- | 'organization'
3241
- | 'organization-title'
3242
- | 'password'
3243
- | 'password-new'
3244
- | 'postal-address'
3245
- | 'postal-address-country'
3246
- | 'postal-address-extended'
3247
- | 'postal-address-extended-postal-code'
3248
- | 'postal-address-locality'
3249
- | 'postal-address-region'
3250
- | 'postal-code'
3251
- | 'street-address'
3252
- | 'sms-otp'
3253
- | 'tel'
3254
- | 'tel-country-code'
3255
- | 'tel-national'
3256
- | 'tel-device'
3257
- | 'url'
3258
- | 'username'
3259
- | 'username-new'
3260
- | 'off'
3261
- | undefined;
3262
- autoCorrect?: boolean | undefined;
3263
- autoFocus?: boolean | undefined;
3264
- blurOnSubmit?: boolean | undefined;
3265
- submitBehavior?: SubmitBehavior | undefined;
3266
- caretHidden?: boolean | undefined;
3267
- contextMenuHidden?: boolean | undefined;
3268
- defaultValue?: string | undefined;
3269
- editable?: boolean | undefined;
3270
- keyboardType?: KeyboardTypeOptions | undefined;
3271
- inputMode?: InputModeOptions | undefined;
3272
- maxLength?: number | undefined;
3273
- multiline?: boolean | undefined;
3274
- onBlur?: ((e: TextInputFocusEvent) => void) | undefined;
3275
- onChange?: ((e: TextInputChangeEvent) => void) | undefined;
3276
- onChangeText?: ((text: string) => void) | undefined;
3277
- onContentSizeChange?:
3278
- | ((e: TextInputContentSizeChangeEvent) => void)
3279
- | undefined;
3280
- onEndEditing?: ((e: TextInputEndEditingEvent) => void) | undefined;
3281
- onPress?: ((e: NativeSyntheticEvent<NativeTouchEvent>) => void) | undefined;
3282
- onPressIn?: ((e: NativeSyntheticEvent<NativeTouchEvent>) => void) | undefined;
3283
- onPressOut?:
3284
- | ((e: NativeSyntheticEvent<NativeTouchEvent>) => void)
3285
- | undefined;
3286
- onFocus?: ((e: TextInputFocusEvent) => void) | undefined;
3287
- onSelectionChange?: ((e: TextInputSelectionChangeEvent) => void) | undefined;
3288
- onSubmitEditing?: ((e: TextInputSubmitEditingEvent) => void) | undefined;
3289
- onScroll?: ((e: TextInputScrollEvent) => void) | undefined;
3290
- onKeyPress?: ((e: TextInputKeyPressEvent) => void) | undefined;
3291
- placeholder?: string | undefined;
3292
- placeholderTextColor?: ColorValue | undefined;
3293
- readOnly?: boolean | undefined;
3294
- returnKeyType?: ReturnKeyTypeOptions | undefined;
3295
- enterKeyHint?: EnterKeyHintTypeOptions | undefined;
3296
- secureTextEntry?: boolean | undefined;
3297
- selectTextOnFocus?: boolean | undefined;
3298
- selection?: {start: number; end?: number | undefined} | undefined;
3299
- selectionColor?: ColorValue | undefined;
3300
- style?: StyleProp<TextStyle> | undefined;
3301
- textAlign?: 'left' | 'center' | 'right' | undefined;
3302
- testID?: string | undefined;
3303
- inputAccessoryViewID?: string | undefined;
3304
- inputAccessoryViewButtonLabel?: string | undefined;
3305
- value?: string | undefined;
3306
- maxFontSizeMultiplier?: number | null | undefined;
3307
- }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3308
  export declare type TextInputScrollEvent =
3309
  NativeSyntheticEvent<TextInputScrollEventData>;
 
3310
- export declare interface TextInputScrollEventData {
3311
- contentOffset: {x: number; y: number};
 
 
3312
- }
 
 
3313
  export declare type TextInputSelectionChangeEvent =
3314
  NativeSyntheticEvent<TextInputSelectionChangeEventData>;
 
3315
- export declare interface TextInputSelectionChangeEventData
 
 
 
 
3316
- extends TargetedEvent {
 
3317
- selection: {
3318
- start: number;
3319
- end: number;
3320
- };
3321
- }
3322
- export declare interface TextInputState {
3323
- currentlyFocusedField(): number;
3324
- currentlyFocusedInput(): HostInstance;
3325
- focusTextInput(textField?: HostInstance): void;
3326
- blurTextInput(textField?: HostInstance): void;
3327
- }
 
 
 
 
 
 
 
 
 
 
 
 
 
3328
  export declare type TextInputSubmitEditingEvent =
3329
  NativeSyntheticEvent<TextInputSubmitEditingEventData>;
 
3330
- export declare interface TextInputSubmitEditingEventData {
 
 
 
 
 
 
 
3331
- text: string;
3332
- }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3333
  export declare type TextLayoutEvent = NativeSyntheticEvent<TextLayoutEventData>;
 
3334
- export declare interface TextLayoutEventData extends TargetedEvent {
3335
- lines: TextLayoutLine[];
 
 
 
 
 
 
 
 
 
 
 
3336
- }
3337
- export declare interface TextLayoutLine {
3338
- ascender: number;
3339
- capHeight: number;
3340
- descender: number;
3341
- height: number;
3342
- text: string;
3343
- width: number;
3344
- x: number;
3345
- xHeight: number;
3346
- y: number;
3347
- }
 
 
3348
- export declare type TextProperties = TextProps;
 
 
3349
- export declare type TextPropertiesAndroid = TextPropsAndroid;
 
3350
- export declare type TextPropertiesIOS = TextPropsIOS;
3351
- export declare interface TextProps
3352
- extends TextPropsIOS,
3353
- TextPropsAndroid,
3354
- AccessibilityProps {
3355
- allowFontScaling?: boolean | undefined;
3356
- children?: React_2.ReactNode | undefined;
3357
- ellipsizeMode?: 'head' | 'middle' | 'tail' | 'clip' | undefined;
3358
- id?: string | undefined;
3359
- lineBreakMode?: 'head' | 'middle' | 'tail' | 'clip' | undefined;
3360
- numberOfLines?: number | undefined;
3361
- onLayout?: ((event: LayoutChangeEvent) => void) | undefined;
3362
- onTextLayout?: ((event: TextLayoutEvent) => void) | undefined;
3363
- onPress?: ((event: GestureResponderEvent) => void) | undefined;
3364
- onPressIn?: ((event: GestureResponderEvent) => void) | undefined;
3365
- onPressOut?: ((event: GestureResponderEvent) => void) | undefined;
3366
- onLongPress?: ((event: GestureResponderEvent) => void) | undefined;
3367
- style?: StyleProp<TextStyle> | undefined;
3368
- testID?: string | undefined;
3369
- nativeID?: string | undefined;
3370
- maxFontSizeMultiplier?: number | null | undefined;
3371
- minimumFontScale?: number | undefined;
3372
- pointerEvents?: ViewStyle['pointerEvents'] | undefined;
3373
- }
3374
- export declare interface TextPropsAndroid {
3375
  disabled?: boolean | undefined;
3376
- selectable?: boolean | undefined;
3377
  selectionColor?: ColorValue | undefined;
3378
- textBreakStrategy?: 'simple' | 'highQuality' | 'balanced' | undefined;
3379
  dataDetectorType?:
3380
- | null
3381
- | 'phoneNumber'
3382
- | 'link'
3383
- | 'email'
3384
- | 'none'
3385
- | 'all'
3386
  | undefined;
 
3387
- android_hyphenationFrequency?: 'normal' | 'none' | 'full' | undefined;
3388
- }
3389
- export declare interface TextPropsIOS {
3390
  adjustsFontSizeToFit?: boolean | undefined;
 
 
 
 
 
 
 
3391
  dynamicTypeRamp?:
 
3392
- | 'caption2'
3393
- | 'caption1'
3394
- | 'footnote'
3395
- | 'subheadline'
3396
- | 'callout'
3397
- | 'body'
3398
- | 'headline'
3399
- | 'title3'
3400
- | 'title2'
3401
- | 'title1'
3402
- | 'largeTitle'
 
3403
  | undefined;
 
3404
  suppressHighlighting?: boolean | undefined;
 
3405
  lineBreakStrategyIOS?:
3406
- | 'none'
3407
- | 'standard'
3408
- | 'hangul-word'
3409
- | 'push-out'
3410
  | undefined;
3411
- }
3412
- export declare interface TextStyle
3413
- extends TextStyleIOS,
3414
- TextStyleAndroid,
3415
- ViewStyle {
3416
- color?: ColorValue | undefined;
3417
- fontFamily?: string | undefined;
3418
- fontSize?: number | undefined;
3419
- fontStyle?: 'normal' | 'italic' | undefined;
3420
- fontWeight?:
3421
- | 'normal'
3422
- | 'bold'
3423
- | '100'
3424
- | '200'
3425
- | '300'
3426
- | '400'
3427
- | '500'
3428
- | '600'
3429
- | '700'
3430
- | '800'
3431
- | '900'
3432
- | 100
3433
- | 200
3434
- | 300
3435
- | 400
3436
- | 500
3437
- | 600
3438
- | 700
3439
- | 800
3440
- | 900
3441
- | 'ultralight'
3442
- | 'thin'
3443
- | 'light'
3444
- | 'medium'
3445
- | 'regular'
3446
- | 'semibold'
3447
- | 'condensedBold'
3448
- | 'condensed'
3449
- | 'heavy'
3450
- | 'black'
3451
- | undefined;
3452
- letterSpacing?: number | undefined;
3453
- lineHeight?: number | undefined;
3454
- textAlign?: 'auto' | 'left' | 'right' | 'center' | 'justify' | undefined;
3455
- textDecorationLine?:
3456
- | 'none'
3457
- | 'underline'
3458
- | 'line-through'
3459
- | 'underline line-through'
3460
- | undefined;
3461
- textDecorationStyle?: 'solid' | 'double' | 'dotted' | 'dashed' | undefined;
3462
- textDecorationColor?: ColorValue | undefined;
3463
- textShadowColor?: ColorValue | undefined;
3464
- textShadowOffset?: {width: number; height: number} | undefined;
3465
- textShadowRadius?: number | undefined;
3466
- textTransform?: 'none' | 'capitalize' | 'uppercase' | 'lowercase' | undefined;
3467
- userSelect?: 'auto' | 'none' | 'text' | 'contain' | 'all' | undefined;
3468
- }
3469
- export declare interface TextStyleAndroid extends ViewStyle {
3470
- textAlignVertical?: 'auto' | 'top' | 'bottom' | 'center' | undefined;
3471
- verticalAlign?: 'auto' | 'top' | 'bottom' | 'middle' | undefined;
3472
- includeFontPadding?: boolean | undefined;
3473
- }
3474
- export declare interface TextStyleIOS extends ViewStyle {
3475
- fontVariant?: FontVariant[] | undefined;
3476
- textDecorationColor?: ColorValue | undefined;
3477
- textDecorationStyle?: 'solid' | 'double' | 'dotted' | 'dashed' | undefined;
3478
- writingDirection?: 'auto' | 'ltr' | 'rtl' | undefined;
3479
- }
3480
- export declare interface ThemeAttributeBackgroundPropType
3481
- extends BaseBackgroundPropType {
3482
- type: 'ThemeAttrAndroid';
3483
- attribute: string;
3484
- }
3485
- declare interface TimerMixin {
3486
- setTimeout: typeof setTimeout;
3487
- clearTimeout: typeof clearTimeout;
3488
- setInterval: typeof setInterval;
3489
- clearInterval: typeof clearInterval;
3490
- setImmediate: typeof setImmediate;
3491
- clearImmediate: typeof clearImmediate;
3492
- requestAnimationFrame: typeof requestAnimationFrame;
3493
- cancelAnimationFrame: typeof cancelAnimationFrame;
3494
- }
3495
  declare type Timespan = {
3496
  startTime: number;
3497
- endTime?: number | undefined;
3498
- totalTime?: number | undefined;
3499
- startExtras?: Extras | undefined;
3500
- endExtras?: Extras | undefined;
3501
  };
 
 
 
 
 
 
 
 
3502
- export declare const ToastAndroid: ToastAndroidStatic;
 
3503
- export declare type ToastAndroid = ToastAndroidStatic;
 
 
 
 
 
 
 
 
 
 
3504
- export declare interface ToastAndroidStatic {
 
 
3505
- show(message: string, duration: number): void;
3506
- showWithGravity(message: string, duration: number, gravity: number): void;
3507
- showWithGravityAndOffset(
3508
- message: string,
3509
- duration: number,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3510
- gravity: number,
3511
- xOffset: number,
3512
- yOffset: number
3513
- ): void;
 
 
 
 
 
 
3514
  SHORT: number;
3515
  LONG: number;
3516
  TOP: number;
3517
  BOTTOM: number;
3518
  CENTER: number;
3519
- }
3520
- export declare interface Touchable {
3521
- onTouchStart?: ((event: GestureResponderEvent) => void) | undefined;
3522
- onTouchMove?: ((event: GestureResponderEvent) => void) | undefined;
3523
- onTouchEnd?: ((event: GestureResponderEvent) => void) | undefined;
3524
- onTouchCancel?: ((event: GestureResponderEvent) => void) | undefined;
3525
- onTouchEndCapture?: ((event: GestureResponderEvent) => void) | undefined;
3526
- }
3527
- export declare const Touchable: {
3528
- TOUCH_TARGET_DEBUG: boolean;
3529
- renderDebugView: (config: {
 
3530
- color: string | number;
 
3531
- hitSlop?: Insets | undefined;
 
3532
- }) => React_2.ReactElement | null;
3533
  };
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3534
- export declare const TouchableHighlight: React_2.ForwardRefExoticComponent<
 
3535
- React_2.PropsWithoutRef<TouchableHighlightProps> & React_2.RefAttributes<View>
 
 
 
 
 
 
 
 
 
 
 
 
 
3536
- >;
 
 
 
 
 
 
 
 
3537
- export declare type TouchableHighlightProperties = TouchableHighlightProps;
3538
- export declare interface TouchableHighlightProps
3539
- extends TouchableWithoutFeedbackProps {
3540
  activeOpacity?: number | undefined;
3541
- onHideUnderlay?: (() => void) | undefined;
3542
- onShowUnderlay?: (() => void) | undefined;
3543
- style?: StyleProp<ViewStyle> | undefined;
3544
  underlayColor?: ColorValue | undefined;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3545
- }
 
3546
- export declare interface TouchableMixin {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3547
- touchableHandleActivePressIn(e: GestureResponderEvent): void;
 
3548
- touchableHandleActivePressOut(e: GestureResponderEvent): void;
 
3549
- touchableHandlePress(e: GestureResponderEvent): void;
 
3550
- touchableHandleLongPress(e: GestureResponderEvent): void;
 
3551
- touchableGetPressRectOffset(): Insets;
 
3552
- touchableGetHighlightDelayMS(): number;
3553
- touchableGetLongPressDelayMS(): number;
3554
- touchableGetPressOutDelayMS(): number;
3555
- touchableGetHitSlop(): Insets;
3556
- }
 
3557
- export declare class TouchableNativeFeedback extends TouchableNativeFeedbackBase {
 
 
 
3558
- static SelectableBackground(
 
 
 
 
3559
- rippleRadius?: number | null
3560
- ): ThemeAttributeBackgroundPropType;
3561
- static SelectableBackgroundBorderless(
 
 
 
 
3562
- rippleRadius?: number | null
3563
- ): ThemeAttributeBackgroundPropType;
3564
- static Ripple(
3565
- color: ColorValue,
3566
  borderless: boolean,
 
 
 
 
3567
- rippleRadius?: number | null
3568
- ): RippleBackgroundPropType;
 
3569
- static canUseNativeForeground(): boolean;
 
 
 
 
 
 
 
 
3570
  }
3571
- export declare const TouchableNativeFeedbackBase: Constructor<TouchableMixin> &
3572
- typeof TouchableNativeFeedbackComponent;
3573
- export declare class TouchableNativeFeedbackComponent extends React_2.Component<TouchableNativeFeedbackProps> {}
3574
- export declare type TouchableNativeFeedbackProperties =
3575
- TouchableNativeFeedbackProps;
3576
- export declare interface TouchableNativeFeedbackProps
3577
- extends TouchableWithoutFeedbackProps,
 
3578
- TVProps {
 
 
 
 
 
 
 
 
 
 
 
 
3579
- background?: BackgroundPropType | undefined;
 
 
 
 
 
 
3580
- useForeground?: boolean | undefined;
3581
- }
 
 
 
 
 
 
 
 
 
 
 
3582
- export declare const TouchableOpacity: React_2.ForwardRefExoticComponent<
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3583
- React_2.PropsWithoutRef<TouchableOpacityProps> & React_2.RefAttributes<View>
 
 
 
 
 
 
 
 
 
 
 
 
 
3584
  >;
 
 
 
3585
- export declare type TouchableOpacityProperties = TouchableOpacityProps;
 
3586
- export declare interface TouchableOpacityProps
3587
- extends TouchableWithoutFeedbackProps,
3588
- TVProps {
3589
  activeOpacity?: number | undefined;
3590
- }
3591
- export declare class TouchableWithoutFeedback extends TouchableWithoutFeedbackBase {}
3592
- export declare const TouchableWithoutFeedbackBase: Constructor<TimerMixin> &
3593
- Constructor<TouchableMixin> &
3594
- typeof TouchableWithoutFeedbackComponent;
3595
- export declare class TouchableWithoutFeedbackComponent extends React_2.Component<TouchableWithoutFeedbackProps> {}
 
 
3596
- export declare type TouchableWithoutFeedbackProperties =
 
3597
- TouchableWithoutFeedbackProps;
 
 
 
 
 
 
3598
- export declare interface TouchableWithoutFeedbackProps
3599
- extends TouchableWithoutFeedbackPropsIOS,
 
 
3600
- TouchableWithoutFeedbackPropsAndroid,
3601
- AccessibilityProps {
3602
- children?: React_2.ReactNode | undefined;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3603
- rejectResponderTermination?: boolean | undefined;
3604
- delayLongPress?: number | undefined;
3605
- delayPressIn?: number | undefined;
3606
- delayPressOut?: number | undefined;
3607
- disabled?: boolean | undefined;
3608
- focusable?: boolean | undefined;
3609
- hitSlop?: null | Insets | number | undefined;
3610
- id?: string | undefined;
3611
- onBlur?: ((e: NativeSyntheticEvent<TargetedEvent>) => void) | undefined;
3612
- onFocus?: ((e: NativeSyntheticEvent<TargetedEvent>) => void) | undefined;
3613
- onLayout?: ((event: LayoutChangeEvent) => void) | undefined;
3614
- onLongPress?: ((event: GestureResponderEvent) => void) | undefined;
3615
- onPress?: ((event: GestureResponderEvent) => void) | undefined;
3616
- onPressIn?: ((event: GestureResponderEvent) => void) | undefined;
3617
- onPressOut?: ((event: GestureResponderEvent) => void) | undefined;
3618
- style?: StyleProp<ViewStyle> | undefined;
3619
- pressRetentionOffset?: null | Insets | number | undefined;
3620
- testID?: string | undefined;
 
 
 
 
 
3621
- }
 
3622
- export declare interface TouchableWithoutFeedbackPropsAndroid {
3623
  touchSoundDisabled?: boolean | undefined;
3624
- }
 
3625
- export declare interface TouchableWithoutFeedbackPropsIOS {}
 
3626
- export declare interface TransformsStyle {
3627
- transform?:
3628
- | Readonly<
3629
- MaximumOneOf<
3630
- PerspectiveTransform &
3631
- RotateTransform &
3632
- RotateXTransform &
3633
- RotateYTransform &
3634
- RotateZTransform &
3635
- ScaleTransform &
3636
- ScaleXTransform &
3637
- ScaleYTransform &
3638
- TranslateXTransform &
 
 
 
 
 
3639
- TranslateYTransform &
3640
- SkewXTransform &
3641
- SkewYTransform &
3642
- MatrixTransform
3643
- >[]
3644
- >
3645
- | string
3646
- | undefined;
3647
- transformOrigin?: Array<string | number> | string | undefined;
3648
- transformMatrix?: Array<number> | undefined;
3649
- rotation?: AnimatableNumericValue | undefined;
3650
- scaleX?: AnimatableNumericValue | undefined;
3651
- scaleY?: AnimatableNumericValue | undefined;
3652
- translateX?: AnimatableNumericValue | undefined;
3653
- translateY?: AnimatableNumericValue | undefined;
3654
- }
3655
- export declare interface TranslateXTransform {
3656
- translateX: AnimatableNumericValue | `${number}%`;
3657
- }
3658
- export declare interface TranslateYTransform {
3659
- translateY: AnimatableNumericValue | `${number}%`;
3660
- }
3661
- export declare interface TurboModule {
3662
- getConstants?(): {};
3663
- }
3664
  export declare namespace TurboModuleRegistry {
3665
  export {get, getEnforcing};
3666
  }
 
3667
- export declare interface TVProps {
3668
  hasTVPreferredFocus?: boolean | undefined;
 
3669
  nextFocusDown?: number | undefined;
 
3670
  nextFocusForward?: number | undefined;
 
3671
  nextFocusLeft?: number | undefined;
 
3672
  nextFocusRight?: number | undefined;
 
3673
  nextFocusUp?: number | undefined;
3674
- }
 
3675
- export declare interface TVViewPropsIOS {
3676
- isTVSelectable?: boolean | undefined;
3677
  hasTVPreferredFocus?: boolean | undefined;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3678
- tvParallaxShiftDistanceX?: number | undefined;
 
3679
- tvParallaxShiftDistanceY?: number | undefined;
 
3680
- tvParallaxTiltAngle?: number | undefined;
 
3681
- tvParallaxMagnification?: number | undefined;
 
 
 
 
 
 
 
 
 
 
 
3682
  }
3683
- export declare const UIManager: UIManagerStatic;
3684
- export declare type UIManager = UIManagerStatic;
3685
- export declare interface UIManagerStatic {
3686
- measure(node: number, callback: MeasureOnSuccessCallback): void;
3687
- measureInWindow(
3688
- node: number,
3689
- callback: MeasureInWindowOnSuccessCallback
3690
- ): void;
3691
- measureLayout(
3692
- node: number,
3693
- relativeToNativeNode: number,
3694
- onFail: () => void /* currently unused */,
3695
- onSuccess: MeasureLayoutOnSuccessCallback
3696
- ): void;
3697
- setLayoutAnimationEnabledExperimental?:
3698
- | ((value: boolean) => void)
3699
- | undefined;
3700
- getViewManagerConfig: (name: string) => {
3701
- Commands: {[key: string]: number};
3702
- };
3703
- hasViewManagerConfig: (name: string) => boolean;
3704
- dispatchViewManagerCommand: (
3705
- reactTag: number | null,
3706
- commandID: number | string,
3707
- commandArgs?: Array<any>
3708
- ) => void;
3709
- }
3710
  declare type UnsafeMixed = unknown;
 
3711
- declare type UnsafeObject = object;
 
 
 
 
 
3712
- export declare function unstable_batchedUpdates<A, R>(
3713
- callback: (a: A) => R,
3714
- a: A
3715
- ): R;
3716
- export declare function unstable_batchedUpdates<R>(callback: () => R): R;
3717
  export declare function useAnimatedValue(
3718
  initialValue: number,
3719
- config?: Animated.AnimatedConfig
3720
  ): Animated.Value;
3721
- export declare function useColorScheme(): ColorSchemeName;
3722
- export declare function useWindowDimensions(): ScaledSize;
3723
- export declare const Vibration: VibrationStatic;
3724
- export declare type Vibration = VibrationStatic;
3725
- export declare interface VibrationStatic {
3726
- vibrate(pattern?: number | number[], repeat?: boolean): void;
3727
- cancel(): void;
3728
- }
3729
- export declare class View extends ViewBase {
3730
- static forceTouchAvailable: boolean;
3731
- }
3732
- export declare const _View: typeof View;
3733
- export declare const ViewBase: Constructor<NativeMethods> &
3734
- typeof ViewComponent;
3735
- export declare class ViewComponent extends React_2.Component<ViewProps> {}
3736
- export declare type ViewProperties = ViewProps;
3737
- export declare type ViewPropertiesAndroid = ViewPropsAndroid;
3738
- export declare type ViewPropertiesIOS = ViewPropsIOS;
3739
- export declare interface ViewProps
3740
- extends ViewPropsAndroid,
3741
- ViewPropsIOS,
3742
- GestureResponderHandlers,
3743
- Touchable,
3744
- PointerEvents,
3745
- AccessibilityProps {
3746
- children?: React_2.ReactNode | undefined;
3747
- hitSlop?: null | Insets | number | undefined;
3748
- id?: string | undefined;
3749
- needsOffscreenAlphaCompositing?: boolean | undefined;
3750
- onLayout?: ((event: LayoutChangeEvent) => void) | undefined;
3751
- pointerEvents?: 'box-none' | 'none' | 'box-only' | 'auto' | undefined;
3752
- removeClippedSubviews?: boolean | undefined;
3753
- style?: StyleProp<ViewStyle> | undefined;
3754
- testID?: string | undefined;
3755
- nativeID?: string | undefined;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3756
  collapsable?: boolean | undefined;
 
3757
  collapsableChildren?: boolean | undefined;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3758
- }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3759
- export declare interface ViewPropsAndroid {
 
 
 
3760
  renderToHardwareTextureAndroid?: boolean | undefined;
 
 
 
 
 
 
 
 
 
 
 
 
 
3761
  focusable?: boolean | undefined;
 
3762
- tabIndex?: 0 | -1 | undefined;
 
 
3763
- }
 
3764
- export declare interface ViewPropsIOS extends TVViewPropsIOS {
3765
  shouldRasterizeIOS?: boolean | undefined;
3766
- }
 
3767
- export declare interface ViewStyle
3768
- extends FlexStyle,
3769
- ShadowStyleIOS,
3770
- TransformsStyle {
3771
- backfaceVisibility?: 'visible' | 'hidden' | undefined;
3772
- backgroundColor?: ColorValue | undefined;
3773
- borderBlockColor?: ColorValue | undefined;
3774
- borderBlockEndColor?: ColorValue | undefined;
3775
- borderBlockStartColor?: ColorValue | undefined;
3776
- borderBottomColor?: ColorValue | undefined;
3777
- borderBottomEndRadius?: AnimatableNumericValue | string | undefined;
3778
- borderBottomLeftRadius?: AnimatableNumericValue | string | undefined;
3779
- borderBottomRightRadius?: AnimatableNumericValue | string | undefined;
3780
- borderBottomStartRadius?: AnimatableNumericValue | string | undefined;
3781
- borderColor?: ColorValue | undefined;
3782
- borderCurve?: 'circular' | 'continuous' | undefined;
3783
- borderEndColor?: ColorValue | undefined;
3784
- borderEndEndRadius?: AnimatableNumericValue | string | undefined;
3785
- borderEndStartRadius?: AnimatableNumericValue | string | undefined;
3786
- borderLeftColor?: ColorValue | undefined;
3787
- borderRadius?: AnimatableNumericValue | string | undefined;
3788
- borderRightColor?: ColorValue | undefined;
3789
- borderStartColor?: ColorValue | undefined;
3790
- borderStartEndRadius?: AnimatableNumericValue | string | undefined;
3791
- borderStartStartRadius?: AnimatableNumericValue | string | undefined;
3792
- borderStyle?: 'solid' | 'dotted' | 'dashed' | undefined;
3793
- borderTopColor?: ColorValue | undefined;
3794
- borderTopEndRadius?: AnimatableNumericValue | string | undefined;
3795
- borderTopLeftRadius?: AnimatableNumericValue | string | undefined;
3796
- borderTopRightRadius?: AnimatableNumericValue | string | undefined;
3797
- borderTopStartRadius?: AnimatableNumericValue | string | undefined;
3798
- outlineColor?: ColorValue | undefined;
3799
- outlineOffset?: AnimatableNumericValue | undefined;
3800
- outlineStyle?: 'solid' | 'dotted' | 'dashed' | undefined;
3801
- outlineWidth?: AnimatableNumericValue | undefined;
3802
- opacity?: AnimatableNumericValue | undefined;
3803
- elevation?: number | undefined;
3804
- pointerEvents?: 'box-none' | 'none' | 'box-only' | 'auto' | undefined;
3805
- isolation?: 'auto' | 'isolate' | undefined;
3806
- cursor?: CursorValue | undefined;
3807
- boxShadow?: ReadonlyArray<BoxShadowValue> | string | undefined;
3808
- filter?: ReadonlyArray<FilterFunction> | string | undefined;
3809
- mixBlendMode?: BlendMode | undefined;
3810
- experimental_backgroundImage?:
3811
- | ReadonlyArray<GradientValue>
3812
- | string
3813
- | undefined;
 
3814
- }
 
3815
- export declare type VirtualizedListProperties<ItemT> =
 
 
 
 
 
3816
- VirtualizedListProps<ItemT>;
 
3817
- export declare type VirtualizedListWithoutPreConfiguredProps<ItemT> = Omit<
 
3818
- VirtualizedListWithoutRenderItemProps<ItemT>,
3819
- 'stickyHeaderIndices'
3820
  >;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3821
  declare type WithDefault<
3822
  Type extends DefaultTypes,
3823
- Value extends Type | string | undefined | null,
3824
- > = Type | undefined | null;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3825
  export declare type WrapperComponentProvider = (
3826
- appParameters: any
3827
- ) => React_2.ComponentType<any>;
3828
- export * from '@react-native/virtualized-lists';
3829
  export {};
 
1
+ import type {ElementRef} from 'react';
2
+ import type {ElementType} from 'react';
3
+ import type {ErrorUtilsT} from '@react-native/js-polyfills/error-guard';
4
+ import {ListRenderItem} from '@react-native/virtualized-lists';
5
+ import {ListRenderItemInfo} from '@react-native/virtualized-lists';
6
+ import * as React from 'react';
7
+ import type {RefSetter} from 'react';
8
+ import {ScrollToLocationParamsType} from '@react-native/virtualized-lists';
9
+ import {SectionBase} from '@react-native/virtualized-lists';
10
+ import type {SectionData} from '@react-native/virtualized-lists';
11
+ import {Separators} from '@react-native/virtualized-lists';
12
  import {VirtualizedListProps} from '@react-native/virtualized-lists';
13
+ import VirtualizedLists from '@react-native/virtualized-lists';
14
+ import {VirtualizedSectionListProps} from '@react-native/virtualized-lists';
15
 
16
+ declare type AccessibilityActionEvent = NativeSyntheticEvent<
17
  Readonly<{
18
  actionName: string;
19
  }>
20
  >;
21
+
22
+ declare type AccessibilityActionInfo = Readonly<{
23
  name: AccessibilityActionName | string;
24
+ label?: string;
25
  }>;
26
+
27
+ declare type ____BlendMode_Internal =
28
+ | 'normal'
29
+ | 'multiply'
30
+ | 'screen'
31
+ | 'overlay'
32
+ | 'darken'
33
+ | 'lighten'
34
+ | 'color-dodge'
35
+ | 'color-burn'
36
+ | 'hard-light'
37
+ | 'soft-light'
38
+ | 'difference'
39
+ | 'exclusion'
40
+ | 'hue'
41
+ | 'saturation'
42
+ | 'color'
43
+ | 'luminosity';
44
+
45
+ declare type ____ColorValue_Internal =
46
+ | null
47
+ | string
48
+ | number
49
+ | NativeColorValue;
50
+
51
+ declare type ____DangerouslyImpreciseAnimatedStyleProp_Internal = StyleProp<
52
+ Partial<AnimatedBaseProps<____DangerouslyImpreciseStyle_Internal>>
53
+ >;
54
+
55
+ declare type ____DangerouslyImpreciseStyle_Internal = Readonly<
56
+ Omit<
57
+ ____DangerouslyImpreciseStyle_InternalCore,
58
+ keyof (____DangerouslyImpreciseStyle_InternalOverrides | {})
59
+ > &
60
+ Omit<____DangerouslyImpreciseStyle_InternalOverrides, keyof {}> & {}
61
+ >;
62
+
63
+ declare type ____DangerouslyImpreciseStyle_InternalCore = Readonly<
64
+ Omit<
65
+ ____TextStyle_Internal,
66
+ keyof {
67
+ resizeMode?: ImageResizeMode;
68
+ objectFit?: 'cover' | 'contain' | 'fill' | 'scale-down' | 'none';
69
+ tintColor?: ____ColorValue_Internal;
70
+ overlayColor?: string;
71
+ }
72
+ > & {
73
+ resizeMode?: ImageResizeMode;
74
+ objectFit?: 'cover' | 'contain' | 'fill' | 'scale-down' | 'none';
75
+ tintColor?: ____ColorValue_Internal;
76
+ overlayColor?: string;
77
+ }
78
+ >;
79
+
80
+ declare type ____DangerouslyImpreciseStyle_InternalOverrides = Readonly<{}>;
81
+
82
+ declare type ____FlattenStyleProp_Helper<
83
+ TStyleProp extends StyleProp<unknown>,
84
+ Depth extends FlattenDepthLimiter[keyof FlattenDepthLimiter] = 9,
85
+ > = Depth extends 0
86
+ ? never
87
+ : TStyleProp extends null | void | false | ''
88
+ ? never
89
+ : TStyleProp extends ReadonlyArray<infer V>
90
+ ? ____FlattenStyleProp_Helper<
91
+ V,
92
+ Depth extends number ? FlattenDepthLimiter[Depth] : 0
93
+ >
94
+ : TStyleProp;
95
+
96
+ declare type ____FlattenStyleProp_Internal<
97
+ TStyleProp extends StyleProp<unknown>,
98
+ > =
99
+ ____FlattenStyleProp_Helper<TStyleProp> extends never
100
+ ? any
101
+ : ____FlattenStyleProp_Helper<TStyleProp>;
102
+
103
+ declare type ____FontVariant_Internal =
104
+ | 'small-caps'
105
+ | 'oldstyle-nums'
106
+ | 'lining-nums'
107
+ | 'tabular-nums'
108
+ | 'common-ligatures'
109
+ | 'no-common-ligatures'
110
+ | 'discretionary-ligatures'
111
+ | 'no-discretionary-ligatures'
112
+ | 'historical-ligatures'
113
+ | 'no-historical-ligatures'
114
+ | 'contextual'
115
+ | 'no-contextual'
116
+ | 'proportional-nums'
117
+ | 'stylistic-one'
118
+ | 'stylistic-two'
119
+ | 'stylistic-three'
120
+ | 'stylistic-four'
121
+ | 'stylistic-five'
122
+ | 'stylistic-six'
123
+ | 'stylistic-seven'
124
+ | 'stylistic-eight'
125
+ | 'stylistic-nine'
126
+ | 'stylistic-ten'
127
+ | 'stylistic-eleven'
128
+ | 'stylistic-twelve'
129
+ | 'stylistic-thirteen'
130
+ | 'stylistic-fourteen'
131
+ | 'stylistic-fifteen'
132
+ | 'stylistic-sixteen'
133
+ | 'stylistic-seventeen'
134
+ | 'stylistic-eighteen'
135
+ | 'stylistic-nineteen'
136
+ | 'stylistic-twenty';
137
+
138
+ declare type ____FontVariantArray_Internal =
139
+ ReadonlyArray<____FontVariant_Internal>;
140
+
141
+ declare type ____FontWeight_Internal =
142
+ | 'normal'
143
+ | 'bold'
144
+ | '100'
145
+ | '200'
146
+ | '300'
147
+ | '400'
148
+ | '500'
149
+ | '600'
150
+ | '700'
151
+ | '800'
152
+ | '900'
153
+ | 100
154
+ | 200
155
+ | 300
156
+ | 400
157
+ | 500
158
+ | 600
159
+ | 700
160
+ | 800
161
+ | 900
162
+ | 'ultralight'
163
+ | 'thin'
164
+ | 'light'
165
+ | 'medium'
166
+ | 'regular'
167
+ | 'semibold'
168
+ | 'condensedBold'
169
+ | 'condensed'
170
+ | 'heavy'
171
+ | 'black';
172
+
173
+ declare type ____ImageStyle_Internal = Readonly<
174
+ Omit<
175
+ ____ImageStyle_InternalCore,
176
+ keyof (____ImageStyle_InternalOverrides | {})
177
+ > &
178
+ Omit<____ImageStyle_InternalOverrides, keyof {}> & {}
179
+ >;
180
+
181
+ declare type ____ImageStyle_InternalCore = Readonly<
182
+ Omit<
183
+ ____ViewStyle_Internal,
184
+ keyof {
185
+ resizeMode?: ImageResizeMode;
186
+ objectFit?: 'cover' | 'contain' | 'fill' | 'scale-down' | 'none';
187
+ tintColor?: ____ColorValue_Internal;
188
+ overlayColor?: string;
189
+ }
190
+ > & {
191
+ resizeMode?: ImageResizeMode;
192
+ objectFit?: 'cover' | 'contain' | 'fill' | 'scale-down' | 'none';
193
+ tintColor?: ____ColorValue_Internal;
194
+ overlayColor?: string;
195
+ }
196
+ >;
197
+
198
+ declare type ____ImageStyle_InternalOverrides = Readonly<{}>;
199
+
200
+ declare type ____ImageStyleProp_Internal = StyleProp<
201
+ Readonly<Partial<____ImageStyle_Internal>>
202
+ >;
203
+
204
+ declare type ____LayoutStyle_Internal = Readonly<{
205
+ display?: 'none' | 'flex' | 'contents';
206
+
207
+ width?: DimensionValue;
208
+
209
+ height?: DimensionValue;
210
+
211
+ bottom?: DimensionValue;
212
+
213
+ end?: DimensionValue;
214
+
215
+ left?: DimensionValue;
216
+
217
+ right?: DimensionValue;
218
+
219
+ start?: DimensionValue;
220
+
221
+ top?: DimensionValue;
222
+
223
+ inset?: DimensionValue;
224
+
225
+ insetBlock?: DimensionValue;
226
+
227
+ insetBlockEnd?: DimensionValue;
228
+
229
+ insetBlockStart?: DimensionValue;
230
+
231
+ insetInline?: DimensionValue;
232
+
233
+ insetInlineEnd?: DimensionValue;
234
+
235
+ insetInlineStart?: DimensionValue;
236
+
237
+ minWidth?: DimensionValue;
238
+
239
+ maxWidth?: DimensionValue;
240
+
241
+ minHeight?: DimensionValue;
242
+
243
+ maxHeight?: DimensionValue;
244
+
245
+ margin?: DimensionValue;
246
+
247
+ marginBlock?: DimensionValue;
248
+
249
+ marginBlockEnd?: DimensionValue;
250
+
251
+ marginBlockStart?: DimensionValue;
252
+
253
+ marginBottom?: DimensionValue;
254
+
255
+ marginEnd?: DimensionValue;
256
+
257
+ marginHorizontal?: DimensionValue;
258
+
259
+ marginInline?: DimensionValue;
260
+
261
+ marginInlineEnd?: DimensionValue;
262
+
263
+ marginInlineStart?: DimensionValue;
264
+
265
+ marginLeft?: DimensionValue;
266
+
267
+ marginRight?: DimensionValue;
268
+
269
+ marginStart?: DimensionValue;
270
+
271
+ marginTop?: DimensionValue;
272
+
273
+ marginVertical?: DimensionValue;
274
+
275
+ padding?: DimensionValue;
276
+
277
+ paddingBlock?: DimensionValue;
278
+
279
+ paddingBlockEnd?: DimensionValue;
280
+
281
+ paddingBlockStart?: DimensionValue;
282
+
283
+ paddingBottom?: DimensionValue;
284
+
285
+ paddingEnd?: DimensionValue;
286
+
287
+ paddingHorizontal?: DimensionValue;
288
+
289
+ paddingInline?: DimensionValue;
290
+
291
+ paddingInlineEnd?: DimensionValue;
292
+
293
+ paddingInlineStart?: DimensionValue;
294
+
295
+ paddingLeft?: DimensionValue;
296
+
297
+ paddingRight?: DimensionValue;
298
+
299
+ paddingStart?: DimensionValue;
300
+
301
+ paddingTop?: DimensionValue;
302
+
303
+ paddingVertical?: DimensionValue;
304
+
305
+ borderWidth?: number;
306
+
307
+ borderBottomWidth?: number;
308
+
309
+ borderEndWidth?: number;
310
+
311
+ borderLeftWidth?: number;
312
+
313
+ borderRightWidth?: number;
314
+
315
+ borderStartWidth?: number;
316
+
317
+ borderTopWidth?: number;
318
+
319
+ position?: 'absolute' | 'relative' | 'static';
320
+
321
+ flexDirection?: 'row' | 'row-reverse' | 'column' | 'column-reverse';
322
+
323
+ flexWrap?: 'wrap' | 'nowrap' | 'wrap-reverse';
324
+
325
+ justifyContent?:
326
+ | 'flex-start'
327
+ | 'flex-end'
328
+ | 'center'
329
+ | 'space-between'
330
+ | 'space-around'
331
+ | 'space-evenly';
332
+
333
+ alignItems?: 'flex-start' | 'flex-end' | 'center' | 'stretch' | 'baseline';
334
+
335
+ alignSelf?:
336
+ | 'auto'
337
+ | 'flex-start'
338
+ | 'flex-end'
339
+ | 'center'
340
+ | 'stretch'
341
+ | 'baseline';
342
+
343
+ alignContent?:
344
+ | 'flex-start'
345
+ | 'flex-end'
346
+ | 'center'
347
+ | 'stretch'
348
+ | 'space-between'
349
+ | 'space-around'
350
+ | 'space-evenly';
351
+
352
+ overflow?: 'visible' | 'hidden' | 'scroll';
353
+
354
+ flex?: number;
355
+ flexGrow?: number;
356
+ flexShrink?: number;
357
+ flexBasis?: number | string;
358
+
359
+ aspectRatio?: number | string;
360
+
361
+ boxSizing?: 'border-box' | 'content-box';
362
+
363
+ zIndex?: number;
364
+
365
+ direction?: 'inherit' | 'ltr' | 'rtl';
366
+
367
+ rowGap?: number | string;
368
+ columnGap?: number | string;
369
+ gap?: number | string;
370
+ }>;
371
+
372
+ declare type ____ShadowStyle_Internal = Readonly<
373
+ Omit<
374
+ ____ShadowStyle_InternalCore,
375
+ keyof (____ShadowStyle_InternalOverrides | {})
376
+ > &
377
+ Omit<____ShadowStyle_InternalOverrides, keyof {}> & {}
378
+ >;
379
+
380
+ declare type ____ShadowStyle_InternalCore = Readonly<{
381
+ shadowColor?: ____ColorValue_Internal;
382
+
383
+ shadowOffset?: Readonly<{
384
+ width?: number;
385
+ height?: number;
386
+ }>;
387
+
388
+ shadowOpacity?: AnimatableNumericValue;
389
+
390
+ shadowRadius?: number;
391
+ }>;
392
+
393
+ declare type ____ShadowStyle_InternalOverrides = Readonly<{}>;
394
+
395
+ declare type ____Styles_Internal = {
396
+ readonly [key: string]: Partial<____DangerouslyImpreciseStyle_Internal>;
397
+ };
398
+
399
+ declare type ____TextStyle_Internal = Readonly<
400
+ Omit<
401
+ ____TextStyle_InternalCore,
402
+ keyof (____TextStyle_InternalOverrides | {})
403
+ > &
404
+ Omit<____TextStyle_InternalOverrides, keyof {}> & {}
405
+ >;
406
+
407
+ declare type ____TextStyle_InternalBase = Readonly<{
408
+ color?: ____ColorValue_Internal;
409
+ fontFamily?: string;
410
+ fontSize?: number;
411
+ fontStyle?: 'normal' | 'italic';
412
+ fontWeight?: ____FontWeight_Internal;
413
+ fontVariant?: ____FontVariantArray_Internal | string;
414
+ textShadowOffset?: Readonly<{
415
+ width: number;
416
+ height: number;
417
+ }>;
418
+ textShadowRadius?: number;
419
+ textShadowColor?: ____ColorValue_Internal;
420
+ letterSpacing?: number;
421
+ lineHeight?: number;
422
+ textAlign?: 'auto' | 'left' | 'right' | 'center' | 'justify';
423
+ textAlignVertical?: 'auto' | 'top' | 'bottom' | 'center';
424
+ includeFontPadding?: boolean;
425
+ textDecorationLine?:
426
+ | 'none'
427
+ | 'underline'
428
+ | 'line-through'
429
+ | 'underline line-through';
430
+ textDecorationStyle?: 'solid' | 'double' | 'dotted' | 'dashed';
431
+ textDecorationColor?: ____ColorValue_Internal;
432
+ textTransform?: 'none' | 'capitalize' | 'uppercase' | 'lowercase';
433
+ userSelect?: 'auto' | 'text' | 'none' | 'contain' | 'all';
434
+ verticalAlign?: 'auto' | 'top' | 'bottom' | 'middle';
435
+ writingDirection?: 'auto' | 'ltr' | 'rtl';
436
+ }>;
437
+
438
+ declare type ____TextStyle_InternalCore = Readonly<
439
+ Omit<____ViewStyle_Internal, keyof (____TextStyle_InternalBase | {})> &
440
+ Omit<____TextStyle_InternalBase, keyof {}> & {}
441
+ >;
442
+
443
+ declare type ____TextStyle_InternalOverrides = Readonly<{}>;
444
+
445
+ declare type ____TextStyleProp_Internal = StyleProp<
446
+ Readonly<Partial<____TextStyle_Internal>>
447
+ >;
448
+
449
+ declare type ____TransformStyle_Internal = Readonly<{
450
+ transform?:
451
+ | ReadonlyArray<
452
+ | {
453
+ readonly perspective: number | AnimatedNode;
454
+ }
455
+ | {
456
+ readonly rotate: string | AnimatedNode;
457
+ }
458
+ | {
459
+ readonly rotateX: string | AnimatedNode;
460
+ }
461
+ | {
462
+ readonly rotateY: string | AnimatedNode;
463
+ }
464
+ | {
465
+ readonly rotateZ: string | AnimatedNode;
466
+ }
467
+ | {
468
+ readonly scale: number | AnimatedNode;
469
+ }
470
+ | {
471
+ readonly scaleX: number | AnimatedNode;
472
+ }
473
+ | {
474
+ readonly scaleY: number | AnimatedNode;
475
+ }
476
+ | {
477
+ readonly translateX: number | string | AnimatedNode;
478
+ }
479
+ | {
480
+ readonly translateY: number | string | AnimatedNode;
481
+ }
482
+ | {
483
+ readonly translate:
484
+ | [number | string | AnimatedNode, number | string | AnimatedNode]
485
+ | AnimatedNode;
486
+ }
487
+ | {
488
+ readonly skewX: string | AnimatedNode;
489
+ }
490
+ | {
491
+ readonly skewY: string | AnimatedNode;
492
+ }
493
+ | {
494
+ readonly matrix:
495
+ | ReadonlyArray<number | AnimatedNode>
496
+ | AnimatedNode;
497
+ }
498
+ >
499
+ | string;
500
+
501
+ transformOrigin?:
502
+ | [string | number, string | number, string | number]
503
+ | string;
504
+ }>;
505
+
506
+ declare type ____ViewStyle_Internal = Readonly<
507
+ Omit<
508
+ ____ViewStyle_InternalCore,
509
+ keyof (____ViewStyle_InternalOverrides | {})
510
+ > &
511
+ Omit<____ViewStyle_InternalOverrides, keyof {}> & {}
512
+ >;
513
+
514
+ declare type ____ViewStyle_InternalBase = Readonly<{
515
+ backfaceVisibility?: 'visible' | 'hidden';
516
+ backgroundColor?: ____ColorValue_Internal;
517
+ borderColor?: ____ColorValue_Internal;
518
+ borderCurve?: 'circular' | 'continuous';
519
+ borderBottomColor?: ____ColorValue_Internal;
520
+ borderEndColor?: ____ColorValue_Internal;
521
+ borderLeftColor?: ____ColorValue_Internal;
522
+ borderRightColor?: ____ColorValue_Internal;
523
+ borderStartColor?: ____ColorValue_Internal;
524
+ borderTopColor?: ____ColorValue_Internal;
525
+ borderBlockColor?: ____ColorValue_Internal;
526
+ borderBlockEndColor?: ____ColorValue_Internal;
527
+ borderBlockStartColor?: ____ColorValue_Internal;
528
+ borderRadius?: AnimatableNumericValue | string;
529
+ borderBottomEndRadius?: AnimatableNumericValue | string;
530
+ borderBottomLeftRadius?: AnimatableNumericValue | string;
531
+ borderBottomRightRadius?: AnimatableNumericValue | string;
532
+ borderBottomStartRadius?: AnimatableNumericValue | string;
533
+ borderEndEndRadius?: AnimatableNumericValue | string;
534
+ borderEndStartRadius?: AnimatableNumericValue | string;
535
+ borderStartEndRadius?: AnimatableNumericValue | string;
536
+ borderStartStartRadius?: AnimatableNumericValue | string;
537
+ borderTopEndRadius?: AnimatableNumericValue | string;
538
+ borderTopLeftRadius?: AnimatableNumericValue | string;
539
+ borderTopRightRadius?: AnimatableNumericValue | string;
540
+ borderTopStartRadius?: AnimatableNumericValue | string;
541
+ borderStyle?: 'solid' | 'dotted' | 'dashed';
542
+ borderWidth?: AnimatableNumericValue;
543
+ borderBottomWidth?: AnimatableNumericValue;
544
+ borderEndWidth?: AnimatableNumericValue;
545
+ borderLeftWidth?: AnimatableNumericValue;
546
+ borderRightWidth?: AnimatableNumericValue;
547
+ borderStartWidth?: AnimatableNumericValue;
548
+ borderTopWidth?: AnimatableNumericValue;
549
+ opacity?: AnimatableNumericValue;
550
+ outlineColor?: ____ColorValue_Internal;
551
+ outlineOffset?: AnimatableNumericValue;
552
+ outlineStyle?: 'solid' | 'dotted' | 'dashed';
553
+ outlineWidth?: AnimatableNumericValue;
554
+ elevation?: number;
555
+ pointerEvents?: 'auto' | 'none' | 'box-none' | 'box-only';
556
+ cursor?: CursorValue;
557
+ boxShadow?: ReadonlyArray<BoxShadowValue> | string;
558
+ filter?: ReadonlyArray<FilterFunction> | string;
559
+ mixBlendMode?: ____BlendMode_Internal;
560
+ experimental_backgroundImage?: ReadonlyArray<GradientValue> | string;
561
+ isolation?: 'auto' | 'isolate';
562
+ }>;
563
+
564
+ declare type ____ViewStyle_InternalCore = Readonly<
565
+ Omit<
566
+ ____LayoutStyle_Internal,
567
+ keyof (
568
+ | ____ShadowStyle_Internal
569
+ | ____TransformStyle_Internal
570
+ | ____ViewStyle_InternalBase
571
+ | {}
572
+ )
573
+ > &
574
+ Omit<
575
+ ____ShadowStyle_Internal,
576
+ keyof (____TransformStyle_Internal | ____ViewStyle_InternalBase | {})
577
+ > &
578
+ Omit<____TransformStyle_Internal, keyof (____ViewStyle_InternalBase | {})> &
579
+ Omit<____ViewStyle_InternalBase, keyof {}> & {}
580
+ >;
581
+
582
+ declare type ____ViewStyle_InternalOverrides = Readonly<{}>;
583
+
584
+ declare type ____ViewStyleProp_Internal = StyleProp<
585
+ Readonly<Partial<____ViewStyle_Internal>>
586
+ >;
587
+
588
+ declare const absoluteFill: any;
589
+
590
+ declare type absoluteFill = typeof absoluteFill;
591
+
592
+ declare const absoluteFillObject: {
593
+ readonly bottom: 0;
594
+ readonly left: 0;
595
+ readonly position: 'absolute';
596
+ readonly right: 0;
597
+ readonly top: 0;
598
+ };
599
+
600
+ declare type absoluteFillObject = typeof absoluteFillObject;
601
+
602
+ declare type AbstractImageAndroid = (
603
+ props: Omit<
604
+ ImageProps,
605
+ keyof {
606
+ ref?: React.Ref<
607
+ | React.ComponentRef<TextInlineImageNativeComponent>
608
+ | React.ComponentRef<ImageViewNativeComponent>
609
+ >;
610
+ }
611
+ > & {
612
+ ref?: React.Ref<
613
+ | React.ComponentRef<TextInlineImageNativeComponent>
614
+ | React.ComponentRef<ImageViewNativeComponent>
615
+ >;
616
+ }
617
+ ) => React.ReactNode;
618
+
619
+ declare type AbstractImageIOS = (
620
+ props: Omit<
621
+ ImageProps,
622
+ keyof {
623
+ ref?: React.Ref<React.ComponentRef<ImageViewNativeComponent>>;
624
+ }
625
+ > & {
626
+ ref?: React.Ref<React.ComponentRef<ImageViewNativeComponent>>;
627
+ }
628
+ ) => React.ReactNode;
629
+
630
+ declare type AccessibilityActionName =
631
  | 'activate'
632
  | 'increment'
633
  | 'decrement'
634
  | 'longpress'
635
  | 'magicTap'
636
  | 'escape';
637
+
638
+ declare type AccessibilityEventDefinitions = Omit<
639
+ AccessibilityEventDefinitionsAndroid,
640
+ keyof (
641
+ | AccessibilityEventDefinitionsIOS
642
+ | {
643
+ change: [boolean];
644
+ reduceMotionChanged: [boolean];
645
+ screenReaderChanged: [boolean];
646
+ }
647
+ )
648
+ > &
649
+ Omit<
650
+ AccessibilityEventDefinitionsIOS,
651
+ keyof {
652
+ change: [boolean];
653
+ reduceMotionChanged: [boolean];
654
+ screenReaderChanged: [boolean];
655
+ }
656
+ > & {
657
+ change: [boolean];
658
+ reduceMotionChanged: [boolean];
659
+ screenReaderChanged: [boolean];
660
+ };
661
+
662
+ declare type AccessibilityEventDefinitionsAndroid = {
663
+ accessibilityServiceChanged: [boolean];
664
+ highTextContrastChanged: [boolean];
665
  };
666
+
 
 
 
667
+ declare type AccessibilityEventDefinitionsIOS = {
668
+ announcementFinished: [
669
+ {
670
+ announcement: string;
671
+ success: boolean;
 
672
+ },
673
+ ];
674
+ boldTextChanged: [boolean];
675
+ grayscaleChanged: [boolean];
676
+ invertColorsChanged: [boolean];
 
 
 
 
677
+ reduceTransparencyChanged: [boolean];
 
 
 
678
+ darkerSystemColorsChanged: [boolean];
679
+ };
680
+
681
+ declare type AccessibilityEventTypes = 'click' | 'focus' | 'viewHoverEnter';
682
+
683
+ export declare const AccessibilityInfo: typeof AccessibilityInfo_2;
684
+
685
+ export declare type AccessibilityInfo = typeof AccessibilityInfo;
686
+
687
+ declare const AccessibilityInfo_2: {
688
+ isBoldTextEnabled(): Promise<boolean>;
689
+
690
+ isGrayscaleEnabled(): Promise<boolean>;
691
+
692
+ isInvertColorsEnabled(): Promise<boolean>;
693
+
694
+ isReduceMotionEnabled(): Promise<boolean>;
695
+
696
+ isHighTextContrastEnabled(): Promise<boolean>;
697
+
698
+ isDarkerSystemColorsEnabled(): Promise<boolean>;
699
+
700
  prefersCrossFadeTransitions(): Promise<boolean>;
701
+
702
+ isReduceTransparencyEnabled(): Promise<boolean>;
703
+
704
+ isScreenReaderEnabled(): Promise<boolean>;
705
+
706
  isAccessibilityServiceEnabled(): Promise<boolean>;
707
+
708
+ addEventListener<K extends keyof AccessibilityEventDefinitions>(
709
+ eventName: K,
 
710
+ handler: (...$$REST$$: AccessibilityEventDefinitions[K]) => void
711
+ ): EventSubscription;
712
+
 
 
 
713
+ setAccessibilityFocus(reactTag: number): void;
714
+
715
+ sendAccessibilityEvent(
716
+ handle: HostInstance,
717
+ eventType: AccessibilityEventTypes
718
+ ): void;
719
+
720
+ announceForAccessibility(announcement: string): void;
721
+
722
  announceForAccessibilityWithOptions(
723
  announcement: string,
724
+ options: {
725
+ queue?: boolean;
726
+ }
727
  ): void;
728
+
729
+ getRecommendedTimeoutMillis(originalTimeout: number): Promise<number>;
730
+ };
731
+
732
+ declare type AccessibilityProps = Readonly<
733
+ Omit<
734
+ AccessibilityPropsAndroid,
735
+ keyof (
736
+ | AccessibilityPropsIOS
737
+ | {
738
+ accessible?: boolean | undefined;
739
+
740
+ accessibilityLabel?: string | undefined;
741
+
742
+ accessibilityHint?: string | undefined;
743
+
744
+ 'aria-label'?: string | undefined;
745
+
746
+ accessibilityRole?: AccessibilityRole | undefined;
747
+
748
+ role?: Role | undefined;
749
+
750
+ accessibilityState?: AccessibilityState | undefined;
751
+ accessibilityValue?: AccessibilityValue | undefined;
752
+
753
+ 'aria-valuemax'?: AccessibilityValue['max'] | undefined;
754
+ 'aria-valuemin'?: AccessibilityValue['min'] | undefined;
755
+ 'aria-valuenow'?: AccessibilityValue['now'] | undefined;
756
+ 'aria-valuetext'?: AccessibilityValue['text'] | undefined;
757
+
758
+ accessibilityActions?:
759
+ | ReadonlyArray<AccessibilityActionInfo>
760
+ | undefined;
761
+
762
+ 'aria-busy'?: boolean | undefined;
763
+ 'aria-checked'?: (boolean | undefined) | 'mixed';
764
+ 'aria-disabled'?: boolean | undefined;
765
+ 'aria-expanded'?: boolean | undefined;
766
+ 'aria-selected'?: boolean | undefined;
767
+
768
+ 'aria-hidden'?: boolean | undefined;
769
+ }
770
+ )
771
+ > &
772
+ Omit<
773
+ AccessibilityPropsIOS,
774
+ keyof {
775
+ accessible?: boolean | undefined;
776
+
777
+ accessibilityLabel?: string | undefined;
778
+
779
+ accessibilityHint?: string | undefined;
780
+
781
+ 'aria-label'?: string | undefined;
782
+
783
+ accessibilityRole?: AccessibilityRole | undefined;
784
+
785
+ role?: Role | undefined;
786
+
787
+ accessibilityState?: AccessibilityState | undefined;
788
+ accessibilityValue?: AccessibilityValue | undefined;
789
+
790
+ 'aria-valuemax'?: AccessibilityValue['max'] | undefined;
791
+ 'aria-valuemin'?: AccessibilityValue['min'] | undefined;
792
+ 'aria-valuenow'?: AccessibilityValue['now'] | undefined;
793
+ 'aria-valuetext'?: AccessibilityValue['text'] | undefined;
794
+
795
+ accessibilityActions?:
796
+ | ReadonlyArray<AccessibilityActionInfo>
797
+ | undefined;
798
+
799
+ 'aria-busy'?: boolean | undefined;
800
+ 'aria-checked'?: (boolean | undefined) | 'mixed';
801
+ 'aria-disabled'?: boolean | undefined;
802
+ 'aria-expanded'?: boolean | undefined;
803
+ 'aria-selected'?: boolean | undefined;
804
+
805
+ 'aria-hidden'?: boolean | undefined;
806
+ }
807
+ > & {
808
+ accessible?: boolean | undefined;
809
+
810
+ accessibilityLabel?: string | undefined;
811
+
812
+ accessibilityHint?: string | undefined;
813
+
814
+ 'aria-label'?: string | undefined;
815
+
816
+ accessibilityRole?: AccessibilityRole | undefined;
817
+
818
+ role?: Role | undefined;
819
+
820
+ accessibilityState?: AccessibilityState | undefined;
821
+ accessibilityValue?: AccessibilityValue | undefined;
822
+
823
+ 'aria-valuemax'?: AccessibilityValue['max'] | undefined;
824
+ 'aria-valuemin'?: AccessibilityValue['min'] | undefined;
825
+ 'aria-valuenow'?: AccessibilityValue['now'] | undefined;
826
+ 'aria-valuetext'?: AccessibilityValue['text'] | undefined;
827
+
828
+ accessibilityActions?: ReadonlyArray<AccessibilityActionInfo> | undefined;
829
+
830
+ 'aria-busy'?: boolean | undefined;
831
+ 'aria-checked'?: (boolean | undefined) | 'mixed';
832
+ 'aria-disabled'?: boolean | undefined;
833
+ 'aria-expanded'?: boolean | undefined;
834
+ 'aria-selected'?: boolean | undefined;
835
+
836
+ 'aria-hidden'?: boolean | undefined;
837
+ }
838
+ >;
839
+
840
+ declare type AccessibilityPropsAndroid = Readonly<{
841
+ accessibilityLabelledBy?: (string | undefined) | (Array<string> | undefined);
842
+
843
  'aria-labelledby'?: string | undefined;
844
+
845
+ accessibilityLiveRegion?: ('none' | 'polite' | 'assertive') | undefined;
846
+
847
  'aria-live'?: ('polite' | 'assertive' | 'off') | undefined;
848
+
849
  importantForAccessibility?:
 
 
 
850
+ | ('auto' | 'yes' | 'no' | 'no-hide-descendants')
851
  | undefined;
852
+ }>;
853
+
854
+ declare type AccessibilityPropsIOS = Readonly<{
 
 
 
 
 
855
  accessibilityIgnoresInvertColors?: boolean | undefined;
856
+
857
+ accessibilityViewIsModal?: boolean | undefined;
858
+
859
  accessibilityShowsLargeContentViewer?: boolean | undefined;
860
+
861
  accessibilityLargeContentTitle?: string | undefined;
862
+
863
+ 'aria-modal'?: boolean | undefined;
864
+
865
+ accessibilityElementsHidden?: boolean | undefined;
866
+
867
+ accessibilityLanguage?: string | undefined;
868
+ }>;
869
+
870
+ declare type AccessibilityRole =
871
  | 'none'
872
  | 'button'
873
+ | 'dropdownlist'
874
  | 'togglebutton'
875
  | 'link'
876
  | 'search'
877
  | 'image'
 
897
  | 'tabbar'
898
  | 'tablist'
899
  | 'timer'
900
  | 'list'
901
+ | 'toolbar'
902
+ | 'grid'
903
+ | 'pager'
904
+ | 'scrollview'
905
+ | 'horizontalscrollview'
906
+ | 'viewgroup'
907
+ | 'webview'
908
+ | 'drawerlayout'
909
+ | 'slidingdrawer'
910
+ | 'iconmenu'
911
+ | string;
912
+
913
+ declare type AccessibilityState = {
914
  disabled?: boolean | undefined;
915
+
916
  selected?: boolean | undefined;
917
+
918
+ checked?: (boolean | undefined) | 'mixed';
919
+
920
  busy?: boolean | undefined;
921
+
922
  expanded?: boolean | undefined;
923
+ };
924
+
925
+ declare type AccessibilityValue = Readonly<{
926
+ min?: number;
927
+
928
+ max?: number;
929
+
930
+ now?: number;
931
+
932
+ text?: string;
933
+ }>;
934
+
935
+ export declare const ActionSheetIOS: typeof ActionSheetIOS_2;
936
+
937
+ export declare type ActionSheetIOS = typeof ActionSheetIOS;
938
+
 
 
 
 
 
 
 
 
 
 
 
 
939
+ declare const ActionSheetIOS_2: {
940
+ showActionSheetWithOptions(
941
  options: ActionSheetIOSOptions,
942
  callback: (buttonIndex: number) => void
943
+ ): void;
944
+
945
+ showShareActionSheetWithOptions(
946
  options: ShareActionSheetIOSOptions,
947
+ failureCallback: Function | ((error: ShareActionSheetError) => void),
948
+ successCallback:
949
+ | Function
950
+ | ((success: boolean, method: null | undefined | string) => void)
951
+ ): void;
952
+
953
  dismissActionSheet: () => void;
954
+ };
955
+
956
+ export declare type ActionSheetIOSOptions = Readonly<{
957
+ title?: string | undefined;
958
+ message?: string | undefined;
959
+ options: Array<string>;
960
+ destructiveButtonIndex?: (number | undefined) | (Array<number> | undefined);
961
+ cancelButtonIndex?: number | undefined;
962
+ anchor?: number | undefined;
963
+ tintColor?: ColorValue | ProcessedColorValue;
964
+ cancelButtonTintColor?: ColorValue | ProcessedColorValue;
965
+ disabledButtonTintColor?: ColorValue | ProcessedColorValue;
966
+ userInterfaceStyle?: string;
967
+ disabledButtonIndices?: Array<number>;
968
+ }>;
969
+
970
+ declare type ActiveCallback = (
971
+ event: GestureResponderEvent,
972
+ gestureState: PanResponderGestureState
973
+ ) => boolean;
974
+
975
+ export declare const ActivityIndicator: typeof ActivityIndicatorWithRef;
976
+
 
 
977
+ export declare type ActivityIndicator = typeof ActivityIndicator;
978
+
979
+ declare type ActivityIndicatorIOSProps = Readonly<{
 
 
980
  hidesWhenStopped?: boolean | undefined;
981
+ }>;
982
+
983
+ export declare type ActivityIndicatorProps = Readonly<
984
+ Omit<
985
+ ViewProps,
986
+ keyof (
987
+ | ActivityIndicatorIOSProps
988
+ | {
989
+ animating?: boolean | undefined;
990
+
991
+ color?: ColorValue | undefined;
992
+
993
+ size?: IndicatorSize | undefined;
994
+ }
995
+ )
996
+ > &
997
+ Omit<
998
+ ActivityIndicatorIOSProps,
999
+ keyof {
1000
+ animating?: boolean | undefined;
1001
+
1002
+ color?: ColorValue | undefined;
1003
+
1004
+ size?: IndicatorSize | undefined;
 
 
1005
+ }
 
 
 
 
 
 
 
1006
+ > & {
1007
+ animating?: boolean | undefined;
1008
+
1009
+ color?: ColorValue | undefined;
1010
+
1011
+ size?: IndicatorSize | undefined;
1012
+ }
1013
+ >;
1014
+
1015
+ declare const ActivityIndicatorWithRef: (
1016
+ props: Omit<
1017
+ ActivityIndicatorProps,
1018
+ keyof {
1019
+ ref?: React.Ref<HostComponent<never>>;
1020
+ }
1021
+ > & {
1022
+ ref?: React.Ref<HostComponent<never>>;
1023
+ }
1024
+ ) => React.ReactNode;
1025
+
1026
+ declare const add: typeof AnimatedImplementation_MODULE_EXPORT.add;
1027
+
1028
+ declare type add = typeof add;
1029
+
1030
+ declare const add_2: (
1031
+ a: AnimatedNode | number,
1032
+ b: AnimatedNode | number
1033
+ ) => AnimatedAddition;
1034
+
1035
+ declare function addChangeListener(
1036
+ listener: ($$PARAM_0$$: {colorScheme: ColorSchemeName | undefined}) => void
1037
+ ): EventSubscription;
1038
+
1039
+ export declare class Alert {
1040
+ static alert(
1041
+ title: null | undefined | string,
1042
+ message?: null | undefined | string,
1043
+ buttons?: AlertButtons,
1044
  options?: AlertOptions
1045
+ ): void;
1046
+ static prompt(
1047
+ title: null | undefined | string,
1048
+ message?: null | undefined | string,
1049
+ callbackOrButtons?:
1050
+ | null
1051
+ | undefined
1052
+ | (((text: string) => void) | AlertButtons),
1053
+ type?: null | undefined | AlertType,
1054
  defaultValue?: string,
1055
  keyboardType?: string,
1056
  options?: AlertOptions
1057
+ ): void;
1058
  }
1059
+
1060
+ export declare type AlertButton = {
1061
+ text?: string;
1062
+ onPress?: (((value?: string) => any) | undefined) | (Function | undefined);
1063
+ isPreferred?: boolean;
1064
+ style?: AlertButtonStyle;
1065
+ };
1066
+
1067
+ declare type AlertButtons = Array<AlertButton>;
1068
+
1069
+ export declare type AlertButtonStyle = 'default' | 'cancel' | 'destructive';
1070
+
1071
+ export declare type AlertOptions = {
1072
+ cancelable?: boolean | undefined;
1073
+ userInterfaceStyle?: 'unspecified' | 'light' | 'dark';
1074
+
1075
+ onDismiss?: (() => void) | undefined;
1076
+ };
1077
+
1078
  export declare type AlertType =
1079
  | 'default'
1080
  | 'plain-text'
1081
  | 'secure-text'
1082
  | 'login-password';
1083
+
1084
+ declare type AndroidDrawable = AndroidDrawableThemeAttr | AndroidDrawableRipple;
1085
+
1086
+ declare type AndroidDrawableRipple = Readonly<{
1087
+ type: 'RippleAndroid';
1088
+ color?: number | undefined;
1089
+ borderless?: boolean | undefined;
1090
+ rippleRadius?: number | undefined;
1091
+ }>;
1092
+
1093
+ declare type AndroidDrawableThemeAttr = Readonly<{
1094
+ type: 'ThemeAttrAndroid';
1095
+ attribute: string;
1096
+ }>;
1097
+
1098
+ export declare type AndroidKeyboardEvent = Readonly<
 
 
 
 
1099
+ Omit<
 
 
 
 
1100
+ BaseKeyboardEvent,
1101
+ keyof {
1102
+ duration: 0;
1103
+ easing: 'keyboard';
1104
+ }
1105
+ > & {
1106
+ duration: 0;
1107
+ easing: 'keyboard';
1108
  }
1109
+ >;
1110
+
1111
+ declare type AndroidPlatform = {
1112
+ OS: 'android';
1113
+ get Version(): number;
1114
+ get constants(): {
1115
+ isTesting: boolean;
1116
+ isDisableAnimations?: boolean;
1117
+ reactNativeVersion: {
1118
+ major: number;
1119
+ minor: number;
1120
+ patch: number;
1121
+ prerelease: string | undefined;
1122
+ };
1123
+ Version: number;
1124
+ Release: string;
1125
+ Serial: string;
1126
+ Fingerprint: string;
1127
+ Model: string;
1128
+ ServerHost?: string;
1129
+ uiMode: string;
1130
+ Brand: string;
1131
+ Manufacturer: string;
1132
  };
1133
+ get isTV(): boolean;
1134
+ get isVision(): boolean;
1135
+ get isTesting(): boolean;
1136
+ get isDisableAnimations(): boolean;
1137
+ select: <T>(spec: PlatformSelectSpec<T>) => T;
1138
+ };
1139
+
1140
+ declare type AndroidProps = Readonly<{
1141
+ nextFocusDown?: number | undefined;
1142
+ nextFocusForward?: number | undefined;
1143
+ nextFocusLeft?: number | undefined;
1144
+ nextFocusRight?: number | undefined;
1145
+ nextFocusUp?: number | undefined;
1146
+ }>;
1147
+
1148
+ declare const AndroidSwitchNativeComponent_MODULE_EXPORT: typeof AndroidSwitchNativeComponent_MODULE_EXPORT_2;
1149
+
1150
+ declare type AndroidSwitchNativeComponent_MODULE_EXPORT =
1151
+ typeof AndroidSwitchNativeComponent_MODULE_EXPORT;
1152
+
1153
+ declare const AndroidSwitchNativeComponent_MODULE_EXPORT_2: NativeType;
1154
+
1155
+ declare type AndroidSwitchNativeComponent_MODULE_EXPORT_2 =
1156
+ typeof AndroidSwitchNativeComponent_MODULE_EXPORT_2;
1157
+
1158
+ declare type AnimatableNumericValue = number | AnimatedNode;
1159
+
1160
+ export declare namespace Animated {
1161
+ export {
1162
+ AnimatedFlatList_MODULE_EXPORT as FlatList,
1163
+ AnimatedImage_MODULE_EXPORT as Image,
1164
+ AnimatedScrollView_MODULE_EXPORT as ScrollView,
1165
+ AnimatedSectionList_MODULE_EXPORT as SectionList,
1166
+ AnimatedText_MODULE_EXPORT as Text,
1167
+ AnimatedView_MODULE_EXPORT as View,
1168
+ AnimatedColor as Color,
1169
+ AnimatedEvent as Event,
1170
+ AnimatedInterpolation as Interpolation,
1171
+ AnimatedNode as Node,
1172
+ AnimatedValue as Value,
1173
+ AnimatedValueXY as ValueXY,
1174
+ AnimatedInterpolation,
1175
+ AnimatedColor,
1176
+ AnimatedValueConfig as AnimatedConfig,
1177
+ AnimatedNode,
1178
+ AnimatedAddition,
1179
+ AnimatedDiffClamp,
1180
+ AnimatedDivision,
1181
+ AnimatedModulo,
1182
+ AnimatedMultiplication,
1183
+ AnimatedSubtraction,
1184
+ add,
1185
+ attachNativeEvent_2 as attachNativeEvent,
1186
+ createAnimatedComponent_2 as createAnimatedComponent,
1187
+ decay_2 as decay,
1188
+ delay_2 as delay,
1189
+ diffClamp_2 as diffClamp,
1190
+ divide_2 as divide,
1191
+ event_3 as event,
1192
+ forkEvent_2 as forkEvent,
1193
+ loop_2 as loop,
1194
+ modulo_2 as modulo,
1195
+ multiply_2 as multiply,
1196
+ parallel_2 as parallel,
1197
+ sequence_2 as sequence,
1198
+ spring_2 as spring,
1199
+ stagger_2 as stagger,
1200
+ subtract_2 as subtract,
1201
+ timing_2 as timing,
1202
+ unforkEvent_2 as unforkEvent,
1203
  };
1204
+ }
1205
+
1206
+ declare class AnimatedAddition extends AnimatedWithChildren {
1207
+ constructor(
1208
+ a: AnimatedNode | number,
1209
+ b: AnimatedNode | number,
1210
+ config?: null | undefined | AnimatedNodeConfig
1211
+ );
1212
+ interpolate<OutputT extends number | string>(
1213
+ config: InterpolationConfigType<OutputT>
1214
+ ): AnimatedInterpolation<OutputT>;
1215
+ }
1216
+
1217
+ declare type AnimatedBaseProps<Props extends {}> = {
1218
+ [K in keyof Props]: K extends NonAnimatedProps
1219
+ ? Props[K]
1220
+ : WithAnimatedValue<Props[K]>;
1221
+ };
1222
+
1223
+ declare class AnimatedColor extends AnimatedWithChildren {
1224
+ r: AnimatedValue;
1225
+ g: AnimatedValue;
1226
+ b: AnimatedValue;
1227
+ a: AnimatedValue;
1228
+ nativeColor: null | undefined | NativeColorValue;
1229
+ constructor(
1230
+ valueIn?: InputValue,
1231
+ config?: null | undefined | AnimatedColorConfig
1232
+ );
1233
+ setValue(value: RgbaValue | ColorValue): void;
1234
+ setOffset(offset: RgbaValue): void;
1235
+ flattenOffset(): void;
1236
+ extractOffset(): void;
1237
+ stopAnimation(callback?: ColorListenerCallback): void;
1238
+ resetAnimation(callback?: ColorListenerCallback): void;
1239
+ }
1240
+
1241
+ declare type AnimatedColorConfig = Readonly<
1242
+ Omit<
1243
+ AnimatedNodeConfig,
1244
+ keyof {
1245
+ useNativeDriver: boolean;
1246
+ }
1247
+ > & {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1248
  useNativeDriver: boolean;
1249
  }
 
 
 
1250
+ >;
1251
+
1252
+ declare type AnimatedComponentType<Props extends {}, Instance = unknown> = (
1253
+ props: Omit<
1254
+ AnimatedProps<Props>,
1255
+ keyof {
1256
+ ref?: React.Ref<Instance>;
1257
+ }
1258
+ > & {
1259
+ ref?: React.Ref<Instance>;
1260
  }
 
 
 
1261
+ ) => React.ReactNode;
1262
+
1263
+ declare class AnimatedDiffClamp extends AnimatedWithChildren {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1264
+ constructor(
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1265
+ a: AnimatedNode,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1266
  min: number,
1267
+ max: number,
1268
+ config?: null | undefined | AnimatedNodeConfig
1269
+ );
1270
+ interpolate<OutputT extends number | string>(
1271
+ config: InterpolationConfigType<OutputT>
1272
+ ): AnimatedInterpolation<OutputT>;
1273
+ }
1274
+
1275
+ declare class AnimatedDivision extends AnimatedWithChildren {
1276
+ constructor(
1277
+ a: AnimatedNode | number,
1278
+ b: AnimatedNode | number,
1279
+ config?: null | undefined | AnimatedNodeConfig
1280
+ );
1281
+ interpolate<OutputT extends number | string>(
1282
+ config: InterpolationConfigType<OutputT>
1283
+ ): AnimatedInterpolation<OutputT>;
1284
+ }
1285
+
1286
+ declare class AnimatedEvent {
1287
+ constructor(
1288
+ argMapping: ReadonlyArray<null | undefined | Mapping>,
1289
+ config: EventConfig
1290
+ );
1291
+ }
1292
+
1293
+ declare const AnimatedFlatList_MODULE_EXPORT: AnimatedComponentType<
1294
+ React.JSX.LibraryManagedAttributes<
1295
+ typeof FlatList,
1296
+ React.ComponentProps<typeof FlatList>
1297
+ >,
1298
+ FlatList<unknown>
1299
+ >;
1300
+
1301
+ declare type AnimatedFlatList_MODULE_EXPORT =
1302
+ typeof AnimatedFlatList_MODULE_EXPORT;
1303
+
1304
+ declare const AnimatedImage_MODULE_EXPORT: AnimatedComponentType<
1305
+ React.JSX.LibraryManagedAttributes<
1306
+ typeof Image_2,
1307
+ React.ComponentProps<typeof Image_2>
1308
+ >,
1309
+ React.ComponentRef<typeof Image_2>
1310
+ >;
1311
+
1312
+ declare type AnimatedImage_MODULE_EXPORT = typeof AnimatedImage_MODULE_EXPORT;
1313
+
1314
+ declare const AnimatedImplementation_MODULE_EXPORT: {
1315
+ Value: typeof AnimatedValue;
1316
+
1317
+ ValueXY: typeof AnimatedValueXY;
1318
+
1319
+ Color: typeof AnimatedColor;
1320
+
1321
+ Interpolation: typeof AnimatedInterpolation;
1322
+
1323
+ Node: typeof AnimatedNode;
1324
+
1325
+ decay: typeof decay;
1326
+
1327
+ timing: typeof timing;
1328
+
1329
+ spring: typeof spring;
1330
+
1331
+ add: typeof add_2;
1332
+
1333
+ subtract: typeof subtract;
1334
+
1335
+ divide: typeof divide;
1336
+
1337
+ multiply: typeof multiply;
1338
+
1339
+ modulo: typeof modulo;
1340
+
1341
+ diffClamp: typeof diffClamp;
1342
+
1343
+ delay: typeof delay;
1344
+
1345
+ sequence: typeof sequence;
1346
+
1347
+ parallel: typeof parallel;
1348
+
1349
+ stagger: typeof stagger;
1350
+
1351
+ loop: typeof loop;
1352
+
1353
+ event: typeof event_2;
1354
+
1355
+ createAnimatedComponent: typeof createAnimatedComponent;
1356
+
1357
+ attachNativeEvent: typeof attachNativeEvent;
1358
+
1359
+ forkEvent: typeof forkEvent;
1360
+ unforkEvent: typeof unforkEvent;
1361
+
1362
+ Event: typeof AnimatedEvent;
1363
+ };
1364
+
1365
+ declare type AnimatedImplementation_MODULE_EXPORT =
1366
+ typeof AnimatedImplementation_MODULE_EXPORT;
1367
+
1368
+ declare class AnimatedInterpolation<
1369
+ OutputT extends number | string,
1370
+ > extends AnimatedWithChildren {
1371
+ constructor(parent: AnimatedNode, config: InterpolationConfigType<OutputT>);
1372
+ interpolate<NewOutputT extends number | string>(
1373
+ config: InterpolationConfigType<NewOutputT>
1374
+ ): AnimatedInterpolation<NewOutputT>;
1375
+ }
1376
+
1377
+ declare class AnimatedModulo extends AnimatedWithChildren {
1378
+ constructor(
1379
+ a: AnimatedNode,
1380
+ modulus: number,
1381
+ config?: null | undefined | AnimatedNodeConfig
1382
+ );
1383
+ interpolate<OutputT extends number | string>(
1384
+ config: InterpolationConfigType<OutputT>
1385
+ ): AnimatedInterpolation<OutputT>;
1386
+ }
1387
+
1388
+ declare class AnimatedMultiplication extends AnimatedWithChildren {
1389
+ constructor(
1390
+ a: AnimatedNode | number,
1391
+ b: AnimatedNode | number,
1392
+ config?: null | undefined | AnimatedNodeConfig
1393
+ );
1394
+ interpolate<OutputT extends number | string>(
1395
+ config: InterpolationConfigType<OutputT>
1396
+ ): AnimatedInterpolation<OutputT>;
1397
+ }
1398
+
1399
+ declare class AnimatedNode {
1400
+ constructor(
1401
+ config?:
1402
+ | null
1403
+ | undefined
1404
+ | Readonly<Omit<AnimatedNodeConfig, keyof {}> & {}>
1405
+ );
1406
+ addListener(callback: (value: any) => unknown): string;
1407
+ removeListener(id: string): void;
1408
+ removeAllListeners(): void;
1409
+ hasListeners(): boolean;
1410
+ toJSON(): unknown;
1411
+ }
1412
+
1413
+ declare type AnimatedNodeConfig = Readonly<{
1414
+ debugID?: string;
1415
+ }>;
1416
+
1417
+ declare type AnimatedProps<Props extends {}> = {
1418
+ [K in keyof Props]: K extends NonAnimatedProps
1419
+ ? Props[K]
1420
+ : WithAnimatedValue<Props[K]>;
1421
+ } & PassThroughProps;
1422
+
1423
+ declare const AnimatedScrollView: AnimatedComponentType<Props_2, Instance>;
1424
+
1425
+ declare const AnimatedScrollView_MODULE_EXPORT: typeof AnimatedScrollView;
1426
+
1427
+ declare type AnimatedScrollView_MODULE_EXPORT =
1428
+ typeof AnimatedScrollView_MODULE_EXPORT;
1429
+
1430
+ declare const AnimatedSectionList_MODULE_EXPORT: AnimatedComponentType<
1431
+ React.JSX.LibraryManagedAttributes<
1432
+ typeof SectionList,
1433
+ React.ComponentProps<typeof SectionList>
1434
+ >,
1435
+ SectionList<any, SectionBase_2<any>>
1436
+ >;
1437
+
1438
+ declare type AnimatedSectionList_MODULE_EXPORT =
1439
+ typeof AnimatedSectionList_MODULE_EXPORT;
1440
+
1441
+ declare class AnimatedSubtraction extends AnimatedWithChildren {
1442
+ constructor(
1443
+ a: AnimatedNode | number,
1444
+ b: AnimatedNode | number,
1445
+ config?: null | undefined | AnimatedNodeConfig
1446
+ );
1447
+ interpolate<OutputT extends number | string>(
1448
+ config: InterpolationConfigType<OutputT>
1449
+ ): AnimatedInterpolation<OutputT>;
1450
+ }
1451
+
1452
+ declare const AnimatedText_MODULE_EXPORT: AnimatedComponentType<
1453
+ React.JSX.LibraryManagedAttributes<
1454
+ typeof Text_2,
1455
+ React.ComponentProps<typeof Text_2>
1456
+ >,
1457
+ React.ComponentRef<typeof Text_2>
1458
+ >;
1459
+
1460
+ declare type AnimatedText_MODULE_EXPORT = typeof AnimatedText_MODULE_EXPORT;
1461
+
1462
+ declare class AnimatedTracking extends AnimatedNode {
1463
+ constructor(
1464
+ value: AnimatedValue,
1465
+ parent: AnimatedNode,
1466
+ animationClass: any,
1467
+ animationConfig: Object,
1468
+ callback?: null | undefined | EndCallback,
1469
+ config?: null | undefined | AnimatedNodeConfig
1470
+ );
1471
+ update(): void;
1472
+ }
1473
+
1474
+ declare class AnimatedValue extends AnimatedWithChildren {
1475
+ constructor(value: number, config?: null | undefined | AnimatedValueConfig);
1476
+ addListener(callback: (value: any) => unknown): string;
1477
+ removeListener(id: string): void;
1478
+ removeAllListeners(): void;
1479
+ setValue(value: number): void;
1480
+ setOffset(offset: number): void;
1481
+ flattenOffset(): void;
1482
+ extractOffset(): void;
1483
+ stopAnimation(callback?: null | undefined | ((value: number) => void)): void;
1484
+ resetAnimation(callback?: null | undefined | ((value: number) => void)): void;
1485
+ interpolate<OutputT extends number | string>(
1486
+ config: InterpolationConfigType<OutputT>
1487
+ ): AnimatedInterpolation<OutputT>;
1488
+ animate(
1489
+ animation: Animation_2,
1490
+ callback: null | undefined | EndCallback
1491
+ ): void;
1492
+ stopTracking(): void;
1493
+ track(tracking: AnimatedTracking): void;
1494
+ }
1495
+
1496
+ declare type AnimatedValueConfig = Readonly<
1497
+ Omit<
1498
+ AnimatedNodeConfig,
1499
+ keyof {
1500
+ useNativeDriver: boolean;
1501
+ }
1502
+ > & {
1503
  useNativeDriver: boolean;
1504
  }
 
 
 
1505
+ >;
1506
+
1507
+ declare class AnimatedValueXY extends AnimatedWithChildren {
 
1508
+ x: AnimatedValue;
1509
+ y: AnimatedValue;
1510
+ constructor(
1511
+ valueIn?:
1512
+ | null
1513
+ | undefined
1514
+ | {
 
1515
+ readonly x: number | AnimatedValue;
1516
+ readonly y: number | AnimatedValue;
1517
+ },
1518
+ config?: null | undefined | AnimatedValueXYConfig
1519
+ );
1520
+ setValue(value: {x: number; y: number}): void;
1521
+ setOffset(offset: {x: number; y: number}): void;
1522
+ flattenOffset(): void;
1523
+ extractOffset(): void;
1524
+ resetAnimation(callback?: (value: {x: number; y: number}) => void): void;
1525
+ stopAnimation(callback?: (value: {x: number; y: number}) => void): void;
1526
+ addListener(callback: ValueXYListenerCallback): string;
1527
+ removeListener(id: string): void;
1528
+ removeAllListeners(): void;
1529
+ getLayout(): {
1530
+ [key: string]: AnimatedValue;
1531
  };
1532
+ getTranslateTransform(): Array<
1533
+ | {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1534
+ translateX: AnimatedValue;
 
 
 
 
 
1535
+ }
 
 
1536
+ | {
1537
+ translateY: AnimatedValue;
1538
+ }
 
 
 
 
 
 
 
 
 
 
 
1539
+ >;
 
 
 
 
 
 
1540
  }
1541
+
1542
+ declare type AnimatedValueXYConfig = Readonly<
1543
+ Omit<
1544
+ AnimatedNodeConfig,
1545
+ keyof {
1546
+ useNativeDriver: boolean;
1547
+ }
1548
+ > & {
1549
+ useNativeDriver: boolean;
1550
+ }
1551
+ >;
1552
+
1553
+ declare const AnimatedView_MODULE_EXPORT: AnimatedComponentType<
1554
+ React.JSX.LibraryManagedAttributes<
1555
+ typeof View,
1556
+ React.ComponentProps<typeof View>
1557
+ >,
1558
+ React.ComponentRef<typeof View>
1559
+ >;
1560
+
1561
+ declare type AnimatedView_MODULE_EXPORT = typeof AnimatedView_MODULE_EXPORT;
1562
+
1563
+ declare class AnimatedWithChildren extends AnimatedNode {}
1564
+
1565
+ declare class Animation_2 {
1566
+ constructor(config: AnimationConfig);
1567
+ start(
1568
+ fromValue: number,
1569
+ onUpdate: (value: number) => void,
1570
+ onEnd: null | undefined | EndCallback,
1571
+ previousAnimation: null | undefined | Animation_2,
1572
+ animatedValue: AnimatedValue
1573
+ ): void;
1574
+ stop(): void;
1575
+ }
1576
+
1577
+ declare type AnimationConfig = Readonly<{
1578
+ isInteraction?: boolean;
1579
+ useNativeDriver: boolean;
1580
+ platformConfig?: PlatformConfig;
1581
+ onComplete?: EndCallback | undefined;
1582
+ iterations?: number;
1583
+ isLooping?: boolean;
1584
+ debugID?: string | undefined;
1585
+ }>;
1586
+
1587
  export declare type AppConfig = {
1588
  appKey: string;
1589
+ component?: ComponentProvider;
1590
+ run?: Runnable;
1591
+ section?: boolean;
1592
  };
1593
+
1594
  export declare namespace Appearance {
 
 
 
 
1595
+ export {getColorScheme, setColorScheme, addChangeListener};
 
 
 
 
 
 
1596
  }
1597
+
1598
+ declare type AppParameters = {
1599
+ initialProps: Readonly<{
1600
+ [$$Key$$: string]: unknown;
1601
+ }>;
1602
+ rootTag: RootTag;
1603
+ fabric?: boolean;
1604
+ };
1605
+
1606
  export declare namespace AppRegistry {
1607
+ export {
1608
+ setWrapperComponentProvider,
 
 
1609
+ setRootViewStyleProvider,
1610
+ registerConfig,
 
1611
+ registerComponent,
 
 
1612
+ registerRunnable,
 
 
1613
+ registerSection,
1614
+ getAppKeys,
1615
+ getSectionKeys,
1616
+ getSections,
1617
+ getRunnable,
1618
+ getRegistry,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1619
+ setComponentProviderInstrumentationHook,
1620
+ runApplication,
1621
+ setSurfaceProps,
1622
+ unmountApplicationComponentAtRootTag,
1623
+ registerHeadlessTask,
 
 
 
1624
+ registerCancellableHeadlessTask,
1625
+ startHeadlessTask,
1626
+ cancelHeadlessTask,
1627
+ TaskCanceller,
1628
+ TaskCancelProvider,
 
1629
+ };
 
 
 
 
 
 
1630
  }
1631
+
1632
+ export declare const AppState: typeof AppState_2;
1633
+
1634
+ export declare type AppState = typeof AppState;
1635
+
1636
+ declare const AppState_2: AppStateImpl;
1637
+
1638
+ export declare type AppStateEvent = keyof AppStateEventDefinitions;
1639
+
1640
+ declare type AppStateEventDefinitions = {
 
 
 
 
 
1641
+ change: [AppStateStatus];
1642
+ memoryWarning: [];
1643
+ blur: [];
1644
+ focus: [];
1645
+ };
1646
+
1647
+ declare class AppStateImpl {
1648
+ currentState: null | undefined | string;
1649
  isAvailable: boolean;
1650
+ constructor();
1651
+ addEventListener<K extends AppStateEvent>(
1652
+ type: K,
1653
+ handler: (...$$REST$$: AppStateEventDefinitions[K]) => void
1654
+ ): EventSubscription;
1655
  }
1656
+
1657
+ export declare type AppStateStatus = 'inactive' | 'background' | 'active';
1658
+
1659
+ declare function attachNativeEvent(
1660
+ viewRef: any,
1661
+ eventName: string,
1662
+ argMapping: ReadonlyArray<null | undefined | Mapping>,
1663
+ platformConfig: null | undefined | PlatformConfig
1664
+ ): {
1665
+ detach: () => void;
1666
+ };
1667
+
1668
+ declare const attachNativeEvent_2: typeof AnimatedImplementation_MODULE_EXPORT.attachNativeEvent;
1669
+
1670
+ declare type attachNativeEvent_2 = typeof attachNativeEvent_2;
1671
+
1672
+ export declare type AutoCapitalize =
 
 
 
1673
+ | 'none'
1674
+ | 'sentences'
1675
+ | 'words'
1676
+ | 'characters';
1677
+
1678
+ declare type AutoCapitalize_2 = 'none' | 'sentences' | 'words' | 'characters';
1679
+
1680
+ export declare const BackHandler: typeof BackHandler_2;
1681
+
1682
+ export declare type BackHandler = typeof BackHandler;
1683
+
1684
+ declare const BackHandler_2: TBackHandler;
1685
+
 
 
 
 
 
1686
+ export declare type BackPressEventName = 'backPress' | 'hardwareBackPress';
1687
+
1688
+ declare type BaseKeyboardEvent = {
1689
+ duration: number;
1690
+ easing: KeyboardEventEasing;
1691
+ endCoordinates: KeyboardMetrics;
1692
+ };
1693
+
1694
  declare function beginAsyncEvent(
1695
  eventName: EventName,
1696
  args?: EventArgs
1697
  ): number;
1698
+
1699
  declare function beginEvent(eventName: EventName, args?: EventArgs): void;
1700
+
1701
+ declare class Blob_2 {
1702
+ constructor(parts: Array<Blob_2 | string>, options?: BlobOptions_2);
1703
+ set data(data: null | undefined | BlobData);
1704
+ get data(): BlobData;
1705
+ slice(start?: number, end?: number, contentType?: string): Blob_2;
1706
+ close(): void;
1707
+ get size(): number;
1708
+ get type(): string;
1709
+ }
1710
+
1711
+ declare type BlobData = {
 
 
1712
+ blobId: string;
1713
+ offset: number;
1714
+ size: number;
1715
+ name?: string;
 
 
 
 
1716
+ type?: string;
1717
+ lastModified?: number;
1718
+ };
1719
+
1720
+ declare type BlobOptions_2 = {
 
1721
+ type: string;
1722
+ lastModified: number;
1723
+ };
1724
+
1725
+ export declare type BlurEvent = NativeSyntheticEvent<TargetedEvent>;
1726
+
1727
  export declare type BoxShadowValue = {
1728
  offsetX: number | string;
1729
  offsetY: number | string;
1730
+ color?: ____ColorValue_Internal;
1731
+ blurRadius?: number | string;
1732
+ spreadDistance?: number | string;
1733
+ inset?: boolean;
1734
  };
1735
+
1736
  declare type BubblingEventHandler<
1737
  T,
1738
  PaperName extends string | never = never,
1739
  > = (event: NativeSyntheticEvent<T>) => void | Promise<void>;
1740
+
1741
+ declare type Builtin = (
1742
+ ...$$REST$$: ReadonlyArray<never>
1743
+ ) => unknown | Date | Error | RegExp;
1744
+
1745
+ export declare const Button: typeof Button_2;
1746
+
1747
+ export declare type Button = typeof Button;
1748
+
1749
+ declare const Button_2: (
1750
+ props: Omit<
1751
+ ButtonProps,
1752
+ keyof {
1753
+ ref?: React.Ref<ButtonRef>;
1754
+ }
1755
+ > & {
1756
+ ref?: React.Ref<ButtonRef>;
1757
+ }
1758
+ ) => React.ReactNode;
1759
+
1760
+ export declare type ButtonProps = Readonly<{
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1761
  title: string;
1762
+
1763
+ onPress: (event?: GestureResponderEvent) => unknown;
1764
+
1765
+ touchSoundDisabled?: boolean | undefined;
1766
+
1767
  color?: ColorValue | undefined;
1768
+
1769
+ hasTVPreferredFocus?: boolean | undefined;
1770
+
1771
+ nextFocusDown?: number | undefined;
1772
+
1773
+ nextFocusForward?: number | undefined;
1774
+
1775
+ nextFocusLeft?: number | undefined;
1776
+
1777
+ nextFocusRight?: number | undefined;
1778
+
1779
+ nextFocusUp?: number | undefined;
1780
+
1781
+ accessibilityLabel?: string | undefined;
1782
+
1783
+ 'aria-label'?: string | undefined;
1784
+
1785
+ disabled?: boolean | undefined;
1786
+
1787
+ testID?: string | undefined;
1788
+
1789
+ accessible?: boolean | undefined;
1790
+ accessibilityActions?: ReadonlyArray<AccessibilityActionInfo> | undefined;
1791
+ onAccessibilityAction?:
1792
+ | ((event: AccessibilityActionEvent) => unknown)
1793
+ | undefined;
1794
+ accessibilityState?: AccessibilityState | undefined;
1795
+
1796
+ 'aria-busy'?: boolean | undefined;
1797
+ 'aria-checked'?: (boolean | undefined) | 'mixed';
1798
+ 'aria-disabled'?: boolean | undefined;
1799
+ 'aria-expanded'?: boolean | undefined;
1800
+ 'aria-selected'?: boolean | undefined;
1801
+
1802
+ importantForAccessibility?:
1803
+ | ('auto' | 'yes' | 'no' | 'no-hide-descendants')
1804
+ | undefined;
1805
+ accessibilityHint?: string | undefined;
1806
+ accessibilityLanguage?: string | undefined;
1807
+ }>;
1808
+
1809
+ declare type ButtonRef = React.ComponentRef<typeof Touchable_2>;
1810
+
1811
+ declare function cancelHeadlessTask(taskId: number, taskKey: string): void;
1812
+
1813
+ declare type Category = string;
1814
+
1815
+ declare const Clipboard_2: {
1816
  getString(): Promise<string>;
1817
+
1818
  setString(content: string): void;
1819
+ };
1820
+
1821
+ declare type Clipboard_2 = typeof Clipboard_2;
1822
+ export {Clipboard_2 as Clipboard};
1823
+
1824
+ declare type CodeFrame = Readonly<{
1825
+ content: string;
1826
+ location:
1827
+ | {
1828
+ row: number;
1829
+ column: number;
1830
+ }
1831
+ | undefined;
1832
+ fileName: string;
1833
+ collapse?: boolean;
1834
+ }>;
1835
+
1836
+ export declare const codegenNativeCommands: typeof codegenNativeCommands_2;
1837
+
1838
+ export declare type codegenNativeCommands = typeof codegenNativeCommands;
1839
+
1840
+ declare function codegenNativeCommands_2<T extends {}>(
1841
+ options: Options_2<keyof T>
1842
  ): T;
1843
+
1844
+ export declare const codegenNativeComponent: typeof codegenNativeComponent_2;
1845
+
1846
+ export declare type codegenNativeComponent = typeof codegenNativeComponent;
1847
+
1848
+ declare function codegenNativeComponent_2<Props extends {}>(
1849
  componentName: string,
1850
+ options?: Options
1851
  ): NativeComponentType<Props>;
1852
+
1853
+ declare namespace CodegenTypes {
1854
  export {
1855
  BubblingEventHandler,
1856
  DirectEventHandler,
1857
  Double,
1858
  Float,
1859
  Int32,
1860
+ UnsafeObject_3 as UnsafeObject,
1861
  UnsafeMixed,
1862
  DefaultTypes,
1863
  WithDefault,
1864
  EventEmitter,
1865
  };
1866
  }
1867
+ export {CodegenTypes};
1868
+
1869
+ declare type ColorListenerCallback = (value: ColorValue) => unknown;
1870
+
1871
+ export declare type ColorSchemeName = 'light' | 'dark' | 'unspecified';
1872
+
1873
+ export declare type ColorValue = ____ColorValue_Internal;
1874
+
1875
+ export declare type ComponentProvider = () => React.ComponentType<any>;
1876
+
1877
  export declare type ComponentProviderInstrumentationHook = (
1878
+ component_: ComponentProvider,
1879
  scopedPerformanceLogger: IPerformanceLogger
1880
+ ) => React.ComponentType<any>;
1881
+
1882
+ declare type ComponentStack = ReadonlyArray<CodeFrame>;
1883
+
1884
+ declare type ComponentStackType = 'legacy' | 'stack';
1885
+
1886
+ declare type ComponentType = HostComponent<NativeProps_3>;
1887
+
1888
+ declare const compose: typeof composeStyles;
1889
+
1890
+ declare type compose = typeof compose;
1891
+
1892
+ declare function composeStyles<T1, T2>(
1893
+ style1: null | undefined | T1,
1894
+ style2: null | undefined | T2
1895
+ ): null | undefined | (T1 | T2 | ReadonlyArray<T1 | T2>);
1896
+
1897
+ declare type CompositeAnimation = {
1898
+ start: (callback?: EndCallback | undefined, isLooping?: boolean) => void;
1899
+ stop: () => void;
1900
+ reset: () => void;
1901
+ };
1902
+
1903
+ declare function configureNext(
1904
+ config: LayoutAnimationConfig,
1905
+ onAnimationDidEnd?: OnAnimationDidEndCallback,
1906
+ onAnimationDidFail?: OnAnimationDidFailCallback
1907
+ ): void;
1908
+
1909
+ declare type ContentAvailable = 1 | null | void;
1910
+
1911
  declare function counterEvent(eventName: EventName, value: number): void;
1912
+
1913
+ declare function create(
1914
+ duration: number,
1915
+ type?: LayoutAnimationType,
1916
+ property?: LayoutAnimationProperty
1917
+ ): LayoutAnimationConfig;
1918
+
1919
+ declare const create_2: <S extends ____Styles_Internal>(obj: S) => Readonly<S>;
1920
+
1921
+ declare type create_2 = typeof create_2;
1922
+
1923
+ declare function createAnimatedComponent<
1924
+ TInstance extends React.ComponentType<any>,
1925
+ >(
1926
+ Component: TInstance
1927
+ ): AnimatedComponentType<
1928
+ Readonly<React.ComponentProps<TInstance>>,
1929
+ React.ComponentRef<TInstance>
1930
+ >;
1931
+
1932
+ declare const createAnimatedComponent_2: typeof AnimatedImplementation_MODULE_EXPORT.createAnimatedComponent;
1933
+
1934
+ declare type createAnimatedComponent_2 = typeof createAnimatedComponent_2;
1935
+
1936
  export declare type CursorValue = 'auto' | 'pointer';
1937
+
1938
+ declare type DangerouslyImpreciseStyle = ____DangerouslyImpreciseStyle_Internal;
1939
+
1940
+ declare type DataDetectorTypesType =
1941
  | 'phoneNumber'
1942
  | 'link'
1943
  | 'address'
1944
  | 'calendarEvent'
 
1946
  | 'flightNumber'
1947
  | 'lookupSuggestion'
1948
  | 'none'
1949
  | 'all';
1950
+
1951
+ declare type DataDetectorTypesType_2 =
1952
+ | 'phoneNumber'
1953
+ | 'link'
1954
+ | 'address'
1955
+ | 'calendarEvent'
1956
+ | 'trackingNumber'
1957
+ | 'flightNumber'
1958
+ | 'lookupSuggestion'
1959
+ | 'none'
1960
+ | 'all';
1961
+
1962
+ declare const decay: (
1963
+ value: AnimatedValue | AnimatedValueXY | AnimatedColor,
1964
+ config: DecayAnimationConfig
1965
+ ) => CompositeAnimation;
1966
+
1967
+ declare const decay_2: typeof AnimatedImplementation_MODULE_EXPORT.decay;
1968
+
1969
+ declare type decay_2 = typeof decay_2;
1970
+
1971
+ declare type DecayAnimationConfig = Readonly<
1972
+ Omit<
1973
+ AnimationConfig,
1974
+ keyof {
1975
+ velocity:
1976
+ | number
1977
+ | Readonly<{
1978
+ x: number;
1979
+ y: number;
1980
+ }>;
1981
+ deceleration?: number;
1982
+ }
1983
+ > & {
1984
+ velocity:
1985
+ | number
1986
+ | Readonly<{
1987
+ x: number;
1988
+ y: number;
1989
+ }>;
1990
+ deceleration?: number;
1991
+ }
1992
+ >;
1993
+
1994
+ declare type DecelerationRateType = 'fast' | 'normal' | number;
1995
+
1996
+ declare type DefaultSectionT = {
1997
  [key: string]: any;
1998
  };
1999
+
2000
  declare type DefaultTypes = number | boolean | string | ReadonlyArray<string>;
2001
+
2002
+ declare const delay: (time: number) => CompositeAnimation;
2003
+
2004
+ declare const delay_2: typeof AnimatedImplementation_MODULE_EXPORT.delay;
2005
+
2006
+ declare type delay_2 = typeof delay_2;
2007
+
2008
+ declare interface DEPRECATED_RCTExport<T extends void = void> {
 
 
 
 
2009
+ readonly getConstants?: () => {};
 
 
2010
  }
2011
+
2012
+ export declare const DeviceEventEmitter: IEventEmitter<RCTDeviceEventDefinitions>;
2013
+
2014
+ export declare type DeviceEventEmitter = typeof DeviceEventEmitter;
2015
+
2016
+ export declare const DeviceInfo: typeof NativeDeviceInfo_MODULE_EXPORT;
2017
+
2018
+ export declare type DeviceInfo = typeof DeviceInfo;
2019
+
2020
+ export declare type DeviceInfoConstants = {
2021
+ readonly Dimensions: DimensionsPayload;
2022
+ readonly isIPhoneX_deprecated?: boolean;
2023
+ };
2024
+
2025
+
2026
+
2027
+ declare const DevMenu: DevMenuStatic;
2028
+
2029
+ export declare type DevMenu = typeof DevMenu;
2030
+
2031
+ declare type DevMenuStatic = {
2032
  show(): void;
2033
+ };
2034
+
2035
+ export declare const DevSettings: typeof DevSettings_2;
2036
+
2037
+ export declare type DevSettings = typeof DevSettings;
2038
+
2039
+ declare let DevSettings_2: {
2040
+ addMenuItem(title: string, handler: () => unknown): void;
2041
+
2042
  reload(reason?: string): void;
2043
+ onFastRefresh(): void;
2044
+ };
2045
+
2046
+ declare type DialogAction = string;
2047
+
2048
+ declare type DialogButtonKey = number;
2049
+
2050
+ declare type DialogOptions = {
2051
+ title?: string;
2052
+ message?: string;
2053
+ buttonPositive?: string;
2054
+ buttonNegative?: string;
2055
+ buttonNeutral?: string;
2056
+ items?: Array<string>;
2057
+ cancelable?: boolean;
2058
+ };
2059
+
2060
+ declare const diffClamp: (
2061
+ a: AnimatedNode,
2062
+ min: number,
2063
+ max: number
2064
+ ) => AnimatedDiffClamp;
2065
+
2066
+ declare const diffClamp_2: typeof AnimatedImplementation_MODULE_EXPORT.diffClamp;
2067
+
2068
+ declare type diffClamp_2 = typeof diffClamp_2;
2069
+
2070
+ export declare class Dimensions {
2071
+ static get(dim: string): DisplayMetrics | DisplayMetricsAndroid;
2072
+ static set(dims: Readonly<DimensionsPayload>): void;
2073
+ static addEventListener(type: 'change', handler: Function): EventSubscription;
2074
  }
2075
+
2076
+ export declare type DimensionsPayload = {
 
 
 
 
 
 
 
 
2077
+ window?: DisplayMetrics;
2078
+ screen?: DisplayMetrics;
 
2079
+ windowPhysicalPixels?: DisplayMetricsAndroid;
2080
+ screenPhysicalPixels?: DisplayMetricsAndroid;
2081
+ };
2082
+
2083
  export declare type DimensionValue =
2084
  | number
2085
+ | string
2086
  | 'auto'
 
2087
+ | AnimatedNode
2088
  | null;
2089
+
2090
  declare type DirectEventHandler<T, PaperName extends string | never = never> = (
2091
  event: NativeSyntheticEvent<T>
2092
  ) => void | Promise<void>;
2093
+
2094
+ declare type DirectEventProps = Readonly<{
2095
+ onAccessibilityAction?:
2096
+ | ((event: AccessibilityActionEvent) => unknown)
2097
+ | undefined;
2098
+
2099
+ onAccessibilityTap?: (() => unknown) | undefined;
2100
+
2101
+ onLayout?: ((event: LayoutChangeEvent) => unknown) | undefined;
2102
+
2103
+ onMagicTap?: (() => unknown) | undefined;
2104
+
2105
+ onAccessibilityEscape?: (() => unknown) | undefined;
2106
+ }>;
2107
+
2108
+ export declare type DisplayMetrics = {
2109
+ width: number;
2110
+ height: number;
2111
+ scale: number;
2112
+ fontScale: number;
2113
+ };
2114
+
2115
+ export declare type DisplayMetricsAndroid = {
2116
+ width: number;
2117
+ height: number;
2118
+ scale: number;
2119
+ fontScale: number;
2120
+ densityDpi: number;
2121
+ };
2122
+
2123
+ declare type DisplayModeType = symbol & {
2124
+ __DisplayModeType__: string;
2125
+ };
2126
+
2127
+ declare const divide: (
2128
+ a: AnimatedNode | number,
2129
+ b: AnimatedNode | number
2130
+ ) => AnimatedDivision;
2131
+
2132
+ declare const divide_2: typeof AnimatedImplementation_MODULE_EXPORT.divide;
2133
+
2134
+ declare type divide_2 = typeof divide_2;
2135
+
2136
+ declare type Double = number;
2137
+
2138
+ export declare class DrawerLayoutAndroid
2139
+ extends React.Component<DrawerLayoutAndroidProps, DrawerLayoutAndroidState>
2140
+ implements DrawerLayoutAndroidMethods
2141
+ {
2142
+ render(): React.ReactNode;
2143
+ openDrawer(): void;
2144
+ closeDrawer(): void;
2145
  blur(): void;
2146
+ focus(): void;
2147
+ measure(callback: MeasureOnSuccessCallback): void;
2148
+ measureInWindow(callback: MeasureInWindowOnSuccessCallback): void;
2149
+ measureLayout(
2150
+ relativeToNativeNode: number,
2151
+ onSuccess: MeasureLayoutOnSuccessCallback,
 
2152
+ onFail?: () => void
2153
+ ): void;
2154
+ setNativeProps(nativeProps: Object): void;
2155
  }
2156
+
2157
+ declare interface DrawerLayoutAndroidMethods {
 
2158
  openDrawer(): void;
2159
+
2160
  closeDrawer(): void;
2161
+
2162
+ blur(): void;
2163
+ focus(): void;
2164
+ measure(callback: MeasureOnSuccessCallback): void;
2165
+ measureInWindow(callback: MeasureInWindowOnSuccessCallback): void;
2166
+ measureLayout(
2167
+ relativeToNativeNode: number,
2168
+ onSuccess: MeasureLayoutOnSuccessCallback,
2169
+ onFail?: () => void
2170
+ ): void;
2171
+ setNativeProps(nativeProps: Object): void;
2172
  }
2173
+
 
 
2174
+ export declare type DrawerLayoutAndroidProps = Readonly<
2175
+ Omit<
2176
+ ViewProps,
2177
+ keyof {
2178
+ keyboardDismissMode?: ('none' | 'on-drag') | undefined;
2179
+
2180
+ drawerBackgroundColor?: ColorValue | undefined;
2181
+
2182
+ drawerPosition: ('left' | 'right') | undefined;
2183
+
2184
+ drawerWidth?: number | undefined;
2185
+
 
 
 
2186
+ drawerLockMode?:
2187
+ | ('unlocked' | 'locked-closed' | 'locked-open')
2188
+ | undefined;
2189
+
2190
+ onDrawerSlide?: ((event: DrawerSlideEvent) => unknown) | undefined;
2191
+
2192
+ onDrawerStateChanged?: ((state: DrawerStates) => unknown) | undefined;
2193
+
2194
+ onDrawerOpen?: (() => unknown) | undefined;
2195
+
2196
+ onDrawerClose?: (() => unknown) | undefined;
2197
+
2198
+ renderNavigationView: () => React.JSX.Element;
2199
+
2200
+ statusBarBackgroundColor?: ColorValue | undefined;
2201
+ }
 
 
2202
+ > & {
2203
+ keyboardDismissMode?: ('none' | 'on-drag') | undefined;
2204
+
2205
+ drawerBackgroundColor?: ColorValue | undefined;
2206
+
2207
+ drawerPosition: ('left' | 'right') | undefined;
2208
+
2209
+ drawerWidth?: number | undefined;
2210
+
2211
+ drawerLockMode?: ('unlocked' | 'locked-closed' | 'locked-open') | undefined;
2212
+
2213
+ onDrawerSlide?: ((event: DrawerSlideEvent) => unknown) | undefined;
2214
+
2215
+ onDrawerStateChanged?: ((state: DrawerStates) => unknown) | undefined;
2216
+
2217
+ onDrawerOpen?: (() => unknown) | undefined;
2218
+
2219
+ onDrawerClose?: (() => unknown) | undefined;
2220
+
2221
+ renderNavigationView: () => React.JSX.Element;
2222
+
2223
+ statusBarBackgroundColor?: ColorValue | undefined;
2224
+ }
2225
+ >;
2226
+
2227
+ declare type DrawerLayoutAndroidState = {
2228
+ drawerOpened: boolean;
2229
+ };
2230
+
2231
+ export declare type DrawerSlideEvent = NativeSyntheticEvent<
2232
+ Readonly<{
2233
+ offset: number;
2234
+ }>
2235
+ >;
2236
+
2237
+ declare type DrawerStates = 'Idle' | 'Dragging' | 'Settling';
2238
+
2239
  export declare type DropShadowValue = {
2240
  offsetX: number | string;
2241
  offsetY: number | string;
2242
+ standardDeviation?: number | string;
2243
+ color?: ____ColorValue_Internal;
2244
  };
2245
+
2246
+ export declare const DynamicColorIOS: (
2247
  tuple: DynamicColorIOSTuple
2248
+ ) => ColorValue;
2249
+
2250
+ export declare type DynamicColorIOS = typeof DynamicColorIOS;
2251
+
2252
  export declare type DynamicColorIOSTuple = {
2253
  light: ColorValue;
2254
  dark: ColorValue;
2255
+ highContrastLight?: ColorValue;
2256
+ highContrastDark?: ColorValue;
2257
  };
2258
+
2259
+ export declare const Easing: typeof EasingStatic;
2260
+
2261
+ export declare type Easing = typeof Easing;
2262
+
2263
+ export declare type EasingFunction = (t: number) => number;
2264
+
2265
+ declare const EasingStatic: {
2266
+ step0(n: number): number;
2267
+
2268
+ step1(n: number): number;
2269
+
2270
+ linear(t: number): number;
2271
+
2272
+ ease(t: number): number;
2273
+
2274
+ quad(t: number): number;
2275
+
2276
+ cubic(t: number): number;
2277
+
2278
  poly(n: number): EasingFunction;
2279
+
2280
+ sin(t: number): number;
2281
+
2282
+ circle(t: number): number;
2283
+
2284
+ exp(t: number): number;
2285
+
2286
  elastic(bounciness: number): EasingFunction;
2287
+
2288
  back(s: number): EasingFunction;
2289
+
2290
+ bounce(t: number): number;
2291
+
2292
  bezier(x1: number, y1: number, x2: number, y2: number): EasingFunction;
2293
+
2294
  in(easing: EasingFunction): EasingFunction;
2295
+
2296
  out(easing: EasingFunction): EasingFunction;
2297
+
2298
  inOut(easing: EasingFunction): EasingFunction;
2299
+ };
2300
+
2301
+ declare type EdgeInsetsOrSizeProp = RectOrSize;
2302
+
2303
+ declare type EdgeInsetsProp = Rect;
2304
+
2305
+ export declare type EdgeInsetsValue = {
2306
+ top: number;
2307
+ left: number;
2308
+ right: number;
2309
+ bottom: number;
 
 
 
 
 
 
 
 
 
2310
+ };
2311
+
2312
  declare function endAsyncEvent(
2313
  eventName: EventName,
2314
  cookie: number,
2315
  args?: EventArgs
2316
  ): void;
2317
+
2318
+ declare type EndCallback = (result: EndResult) => void;
2319
+
2320
  declare function endEvent(args?: EventArgs): void;
2321
+
2322
+ declare type EndResult = {
 
2323
+ finished: boolean;
2324
+ value?: number;
2325
+ };
2326
+
2327
+ declare type EnterKeyHintType = 'done' | 'go' | 'next' | 'search' | 'send';
2328
+
2329
+ declare type EnterKeyHintType_2 = 'done' | 'go' | 'next' | 'search' | 'send';
2330
+
2331
+ declare type EnterKeyHintTypeAndroid = 'previous';
2332
+
2333
+ declare type EnterKeyHintTypeAndroid_2 = 'previous';
2334
+
2335
+ declare type EnterKeyHintTypeIOS = 'enter';
2336
+
2337
+ declare type EnterKeyHintTypeIOS_2 = 'enter';
2338
+
2339
  export declare type EnterKeyHintTypeOptions =
2340
  | EnterKeyHintType
2341
  | EnterKeyHintTypeAndroid
2342
  | EnterKeyHintTypeIOS;
2343
+
2344
+ declare type EnterKeyHintTypeOptions_2 =
 
2345
+ | EnterKeyHintType_2
2346
+ | EnterKeyHintTypeAndroid_2
2347
+ | EnterKeyHintTypeIOS_2;
2348
+
2349
+ declare type ErrorUtils_2 = ErrorUtilsT;
 
 
 
2350
  export {ErrorUtils_2 as ErrorUtils};
2351
+
2352
+ declare const event_2: (
2353
+ argMapping: ReadonlyArray<null | undefined | Mapping>,
2354
+ config: EventConfig
2355
+ ) => any;
2356
+
2357
+ declare const event_3: typeof AnimatedImplementation_MODULE_EXPORT.event;
2358
+
2359
+ declare type event_3 = typeof event_3;
2360
+
2361
+ declare type EventArgs =
2362
+ | null
2363
+ | undefined
2364
+ | {
2365
+ [$$Key$$: string]: string;
2366
+ };
2367
+
2368
+ declare type EventConfig = {
2369
+ listener?: Function | undefined;
2370
+ useNativeDriver: boolean;
2371
+ platformConfig?: PlatformConfig;
2372
+ };
2373
+
2374
  declare type EventEmitter<T> = (
2375
+ handler: ($$PARAM_0$$: T) => void | Promise<void>
2376
+ ) => EventSubscription;
2377
+
2378
+ declare type EventHandlers = Readonly<{
 
 
 
2379
+ onBlur: (event: BlurEvent) => void;
2380
+ onClick: (event: GestureResponderEvent) => void;
2381
+ onFocus: (event: FocusEvent_2) => void;
2382
+ onMouseEnter?: (event: MouseEvent_2) => void;
2383
+ onMouseLeave?: (event: MouseEvent_2) => void;
2384
+ onPointerEnter?: (event: PointerEvent_2) => void;
2385
+ onPointerLeave?: (event: PointerEvent_2) => void;
2386
+ onResponderGrant: (event: GestureResponderEvent) => void | boolean;
2387
+ onResponderMove: (event: GestureResponderEvent) => void;
2388
+ onResponderRelease: (event: GestureResponderEvent) => void;
2389
+ onResponderTerminate: (event: GestureResponderEvent) => void;
2390
+ onResponderTerminationRequest: () => boolean;
2391
+ onStartShouldSetResponder: () => boolean;
 
2392
+ }>;
2393
+
2394
  declare type EventName = string | (() => string);
2395
+
2396
+ declare interface EventSubscription {
 
 
 
 
2397
  remove(): void;
2398
  }
2399
+
2400
+ declare type ExceptionData = {
 
 
2401
+ message: string;
 
 
2402
+ originalMessage: string | undefined;
2403
+ name: string | undefined;
2404
+ componentStack: string | undefined;
2405
+ stack: Array<StackFrame>;
2406
+ id: number;
2407
+ isFatal: boolean;
2408
+ extraData?: Object;
2409
+ };
2410
+
2411
+ export declare const experimental_LayoutConformance: (
2412
+ props: LayoutConformanceProps
2413
+ ) => React.ReactNode;
2414
+
2415
+ export declare type experimental_LayoutConformance =
2416
+ typeof experimental_LayoutConformance;
2417
+
2418
+ declare const exported: (
2419
+ props: Omit<
2420
+ ViewProps,
2421
+ keyof {
2422
+ ref?: React.Ref<React.ComponentRef<typeof View>>;
2423
+ }
2424
+ > & {
2425
+ ref?: React.Ref<React.ComponentRef<typeof View>>;
2426
+ }
2427
+ ) => React.ReactNode;
2428
+
2429
+ export declare type ExtendedExceptionData = ExceptionData & {
2430
+ isComponentError: boolean;
2431
+ };
2432
+
2433
+ declare type ExtrapolateType = 'extend' | 'identity' | 'clamp';
2434
+
2435
+ declare type Extras = {
2436
+ [key: string]: ExtraValue;
2437
+ };
2438
+
2439
  declare type ExtraValue = number | string | boolean;
2440
+
2441
+ declare type FetchResult = {
2442
  NewData: 'UIBackgroundFetchResultNewData';
2443
  NoData: 'UIBackgroundFetchResultNoData';
2444
  ResultFailed: 'UIBackgroundFetchResultFailed';
2445
  };
2446
+
2447
+ declare type FilterFunction =
2448
+ | {
2449
+ brightness: number | string;
2450
+ }
2451
+ | {
2452
+ blur: number | string;
2453
+ }
2454
+ | {
2455
+ contrast: number | string;
2456
+ }
2457
+ | {
2458
+ grayscale: number | string;
2459
+ }
2460
+ | {
2461
+ hueRotate: number | string;
2462
+ }
2463
+ | {
2464
+ invert: number | string;
2465
+ }
2466
+ | {
2467
+ opacity: number | string;
2468
+ }
2469
+ | {
2470
+ saturate: number | string;
2471
+ }
2472
+ | {
2473
+ sepia: number | string;
2474
+ }
2475
+ | {
2476
+ dropShadow: DropShadowValue | string;
2477
+ };
2478
+
2479
+ export declare function findNodeHandle<TElementType extends ElementType>(
 
 
 
2480
+ componentOrHandle: null | undefined | (ElementRef<TElementType> | number)
 
2481
+ ): null | undefined | number;
2482
+
2483
+ export declare class FlatList<ItemT = any> extends React.PureComponent<
 
2484
  FlatListProps<ItemT>
2485
+ > {
 
2486
+ scrollToEnd(
2487
+ params?:
2488
+ | null
2489
+ | undefined
2490
+ | {
2491
+ animated?: boolean | undefined;
2492
+ }
2493
+ ): void;
2494
+ scrollToIndex(params: {
2495
+ animated?: boolean | undefined;
2496
  index: number;
2497
+ viewOffset?: number;
2498
+ viewPosition?: number;
2499
+ }): void;
2500
+ scrollToItem(params: {
2501
+ animated?: boolean | undefined;
2502
  item: ItemT;
2503
+ viewOffset?: number;
2504
+ viewPosition?: number;
2505
+ }): void;
2506
+ scrollToOffset(params: {
2507
+ animated?: boolean | undefined;
2508
  offset: number;
2509
+ }): void;
2510
+ recordInteraction(): void;
2511
+ flashScrollIndicators(): void;
2512
+ getScrollResponder(): null | undefined | ScrollResponderType;
2513
+ getNativeScrollRef():
2514
+ | (null | undefined | React.ComponentRef<typeof View>)
2515
+ | (null | undefined | React.ComponentRef<ScrollViewNativeComponent>);
 
 
2516
+ getScrollableNode(): any;
2517
+ setNativeProps(props: {[$$Key$$: string]: unknown}): void;
2518
+ constructor(props: FlatListProps<ItemT>);
2519
+ componentDidUpdate(prevProps: FlatListProps<ItemT>): void;
2520
+ render(): React.ReactNode;
2521
  }
2522
+
2523
+ declare type FlatListBaseProps<ItemT> = Omit<
2524
+ RequiredProps<ItemT>,
2525
+ keyof (OptionalProps<ItemT> | {})
2526
+ > &
2527
+ Omit<OptionalProps<ItemT>, keyof {}> & {};
2528
+
2529
+ export declare type FlatListProps<ItemT> = Omit<
2530
+ Omit<
2531
+ VirtualizedListProps_2,
 
 
 
2532
+ | 'data'
2533
+ | 'getItem'
2534
+ | 'getItemCount'
2535
+ | 'getItemLayout'
2536
+ | 'renderItem'
2537
+ | 'keyExtractor'
2538
+ >,
2539
+ keyof (FlatListBaseProps<ItemT> | {})
2540
+ > &
2541
+ Omit<FlatListBaseProps<ItemT>, keyof {}> & {};
2542
+
 
 
 
 
 
 
 
 
 
2543
+ declare const flatten: typeof flattenStyle_MODULE_EXPORT;
2544
+
2545
+ declare type flatten = typeof flatten;
2546
+
2547
+ declare type FlattenDepthLimiter = [void, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
2548
+
2549
+ declare function flattenStyle<
2550
+ TStyleProp extends ____DangerouslyImpreciseAnimatedStyleProp_Internal,
2551
+ >(
2552
+ style: null | undefined | TStyleProp
2553
+ ): null | undefined | ____FlattenStyleProp_Internal<TStyleProp>;
2554
+
2555
+ declare const flattenStyle_MODULE_EXPORT: typeof flattenStyle;
2556
+
2557
+ declare type flattenStyle_MODULE_EXPORT = typeof flattenStyle_MODULE_EXPORT;
2558
+
2559
+ declare type Float = number;
2560
+
2561
+ declare type FocusEvent_2 = NativeSyntheticEvent<TargetedEvent>;
2562
+ export {FocusEvent_2 as FocusEvent};
2563
+
2564
+ declare type FocusEventProps = Readonly<{
2565
+ onBlur?: ((event: BlurEvent) => void) | undefined;
 
 
 
 
 
 
 
 
2566
+ onBlurCapture?: ((event: BlurEvent) => void) | undefined;
2567
+ onFocus?: ((event: FocusEvent_2) => void) | undefined;
2568
+ onFocusCapture?: ((event: FocusEvent_2) => void) | undefined;
2569
+ }>;
2570
+
2571
+ declare function forkEvent(
2572
+ event: (null | undefined | AnimatedEvent) | (null | undefined | Function),
2573
+ listener: Function
2574
+ ): AnimatedEvent | Function;
2575
+
2576
+ declare const forkEvent_2: typeof AnimatedImplementation_MODULE_EXPORT.forkEvent;
2577
+
2578
+ declare type forkEvent_2 = typeof forkEvent_2;
2579
+
2580
+ declare class FormData_2 {
2581
+ constructor();
2582
+ append(key: string, value: FormDataValue_2): void;
2583
+ getAll(key: string): Array<FormDataValue_2>;
2584
+ getParts(): Array<FormDataPart_2>;
2585
  }
2586
+
2587
+ declare type FormDataPart_2 =
2588
+ | {
2589
+ string: string;
2590
+ headers: Headers_2;
2591
+ }
2592
+ | {
2593
+ uri: string;
2594
+ headers: Headers_2;
2595
+ name?: string;
2596
+ type?: string;
2597
+ };
2598
+
2599
+ declare type FormDataValue_2 =
2600
+ | string
2601
+ | {
2602
+ name?: string;
2603
+ type?: string;
2604
+ uri: string;
2605
+ };
2606
+
2607
+ export declare type GestureResponderEvent =
2608
+ ResponderSyntheticEvent<NativeTouchEvent>;
2609
+
2610
+ declare type GestureResponderHandlerMethods = {
 
 
2611
+ onMoveShouldSetResponder: (event: GestureResponderEvent) => boolean;
2612
+ onMoveShouldSetResponderCapture: (event: GestureResponderEvent) => boolean;
2613
+ onResponderEnd: (event: GestureResponderEvent) => void;
2614
+ onResponderGrant: (event: GestureResponderEvent) => boolean;
2615
+ onResponderMove: (event: GestureResponderEvent) => void;
2616
+ onResponderReject: (event: GestureResponderEvent) => void;
2617
+ onResponderRelease: (event: GestureResponderEvent) => void;
2618
+ onResponderStart: (event: GestureResponderEvent) => void;
2619
+ onResponderTerminate: (event: GestureResponderEvent) => void;
2620
+ onResponderTerminationRequest: (event: GestureResponderEvent) => boolean;
2621
+ onStartShouldSetResponder: (event: GestureResponderEvent) => boolean;
2622
+ onStartShouldSetResponderCapture: (event: GestureResponderEvent) => boolean;
2623
+ };
2624
+
2625
+ export declare type GestureResponderHandlers = Readonly<{
 
 
 
 
 
2626
+ onMoveShouldSetResponder?:
 
2627
+ | ((e: GestureResponderEvent) => boolean)
2628
  | undefined;
2629
+
2630
+ onMoveShouldSetResponderCapture?:
 
2631
+ | ((e: GestureResponderEvent) => boolean)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2632
  | undefined;
2633
+
 
 
 
 
2634
+ onResponderGrant?: ((e: GestureResponderEvent) => void | boolean) | undefined;
2635
+
2636
+ onResponderMove?: ((e: GestureResponderEvent) => void) | undefined;
2637
+
2638
+ onResponderReject?: ((e: GestureResponderEvent) => void) | undefined;
2639
+
2640
+ onResponderRelease?: ((e: GestureResponderEvent) => void) | undefined;
2641
+ onResponderStart?: ((e: GestureResponderEvent) => void) | undefined;
2642
+ onResponderEnd?: ((e: GestureResponderEvent) => void) | undefined;
2643
+
2644
+ onResponderTerminate?: ((e: GestureResponderEvent) => void) | undefined;
2645
+
 
2646
+ onResponderTerminationRequest?:
 
2647
+ | ((e: GestureResponderEvent) => boolean)
2648
  | undefined;
2649
+
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2650
  onStartShouldSetResponder?:
2651
+ | ((e: GestureResponderEvent) => boolean)
2652
  | undefined;
2653
+
 
 
 
 
 
 
 
 
 
 
 
 
2654
  onStartShouldSetResponderCapture?:
2655
+ | ((e: GestureResponderEvent) => boolean)
2656
  | undefined;
 
 
2657
+ }>;
2658
+
2659
+ declare function get<T extends TurboModule>(name: string): null | undefined | T;
2660
+
2661
+ declare function getAppKeys(): ReadonlyArray<string>;
2662
+
2663
+ declare function getColorScheme(): null | undefined | ColorSchemeName;
2664
+
2665
  declare function getEnforcing<T extends TurboModule>(name: string): T;
2666
+
2667
+ declare function getRegistry(): Registry;
2668
+
2669
+ declare function getRunnable(appKey: string): null | undefined | Runnable;
2670
+
2671
+ declare function getSectionKeys(): ReadonlyArray<string>;
2672
+
2673
+ declare function getSections(): Runnables;
2674
+
2675
+ declare type GradientValue = {
2676
  type: 'linearGradient';
2677
+ direction?: string;
2678
  colorStops: ReadonlyArray<{
2679
+ color: ____ColorValue_Internal;
2680
+ positions?: ReadonlyArray<string>;
2681
  }>;
2682
  };
2683
+
2684
+ declare const hairlineWidth: number;
2685
+
2686
+ declare type hairlineWidth = typeof hairlineWidth;
2687
+
2688
  export declare type Handle = number;
2689
+
2690
+ declare type Headers_2 = {
2691
+ [name: string]: string;
2692
+ };
2693
+
2694
+ export declare type HostComponent<Config extends {}> = (
2695
+ props: Omit<
2696
+ Config,
 
2697
+ keyof {
2698
+ ref: React.Ref<HostInstance>;
2699
+ }
2700
+ > & {
2701
+ ref: React.Ref<HostInstance>;
2702
+ }
2703
+ ) => React.ReactNode;
2704
+
2705
  export declare type HostInstance = NativeMethods;
2706
+
 
2707
+ export declare const I18nManager: {
2708
+ getConstants: () => I18nManagerConstants;
2709
+ allowRTL: (shouldAllow: boolean) => void;
2710
+ forceRTL: (shouldForce: boolean) => void;
2711
+ swapLeftAndRightInRTL: (flipStyles: boolean) => void;
2712
+ isRTL: I18nManagerConstants['isRTL'];
2713
+ doLeftAndRightSwapInRTL: I18nManagerConstants['doLeftAndRightSwapInRTL'];
2714
+ };
2715
+
 
2716
+ export declare type I18nManager = typeof I18nManager;
2717
+
2718
+ declare type I18nManagerConstants = {
2719
  doLeftAndRightSwapInRTL: boolean;
2720
+ isRTL: boolean;
2721
+ localeIdentifier?: string | undefined;
2722
+ };
2723
+
2724
+ declare interface IEventEmitter<
2725
+ TEventToArgsMap extends Readonly<Record<string, ReadonlyArray<UnsafeObject>>>,
2726
+ > {
2727
+ addListener<TEvent extends keyof TEventToArgsMap>(
2728
+ eventType: TEvent,
2729
+ listener: (...args: TEventToArgsMap[TEvent]) => unknown,
2730
+ context?: unknown
2731
+ ): EventSubscription;
2732
+ emit<TEvent extends keyof TEventToArgsMap>(
2733
+ eventType: TEvent,
2734
+ ...args: TEventToArgsMap[TEvent]
2735
+ ): void;
2736
+ removeAllListeners<TEvent extends keyof TEventToArgsMap>(
2737
+ eventType?: TEvent | undefined
2738
+ ): void;
2739
+ listenerCount<TEvent extends keyof TEventToArgsMap>(
2740
+ eventType: TEvent
2741
+ ): number;
2742
  }
2743
+
2744
+ export declare type IgnorePattern = string | RegExp;
2745
+
2746
+ declare interface ILogBox {
2747
+ install(): void;
2748
+ uninstall(): void;
2749
+ isInstalled(): boolean;
2750
+ ignoreLogs($$PARAM_0$$: ReadonlyArray<IgnorePattern>): void;
2751
+ ignoreAllLogs(value?: boolean): void;
2752
+ clearAllLogs(): void;
2753
+ addLog(log: LogData): void;
2754
+ addException(error: ExtendedExceptionData): void;
2755
+ }
2756
+
2757
+ declare const Image_2: Image_3;
2758
+
2759
+ declare type Image_2 = typeof Image_2;
2760
+ export {Image_2 as Image};
2761
+
2762
+ declare type Image_3 = ImageIOS | ImageAndroid;
2763
+
2764
+ declare type Image_4 = typeof Image_2;
2765
+
2766
+ declare type ImageAndroid = AbstractImageAndroid & ImageComponentStaticsAndroid;
2767
+
2768
+ export declare class ImageBackground extends React.Component<ImageBackgroundProps> {
2769
+ setNativeProps(props: {}): void;
2770
+ render(): React.ReactNode;
2771
+ }
2772
+
2773
+ export declare type ImageBackgroundProps = Readonly<
2774
+ Omit<
2775
+ ImageProps,
2776
+ keyof {
2777
+ children?: React.ReactNode;
2778
+
2779
+ style?: ViewStyleProp | undefined;
2780
+
2781
+ imageStyle?: ImageStyleProp | undefined;
2782
+
2783
+ imageRef?: RefSetter<ElementRef<Image_4>>;
2784
+ }
2785
+ > & {
2786
+ children?: React.ReactNode;
2787
+
2788
+ style?: ViewStyleProp | undefined;
2789
+
2790
+ imageStyle?: ImageStyleProp | undefined;
2791
+
2792
+ imageRef?: RefSetter<ElementRef<Image_4>>;
2793
+ }
2794
+ >;
2795
+
2796
+ declare type ImageComponentStaticsAndroid = Readonly<
2797
+ Omit<
2798
+ ImageComponentStaticsIOS,
2799
+ keyof {
2800
+ abortPrefetch(requestId: number): void;
2801
+ }
2802
+ > & {
2803
+ abortPrefetch(requestId: number): void;
2804
+ }
2805
+ >;
2806
+
2807
+ declare type ImageComponentStaticsIOS = Readonly<{
2808
+ getSize(uri: string): Promise<ImageSize>;
2809
+ getSize(
2810
  uri: string,
2811
  success: (width: number, height: number) => void,
2812
+ failure?: (error: unknown) => void
2813
  ): void;
2814
+ getSizeWithHeaders(
2815
  uri: string,
2816
+ headers: {
2817
+ [$$Key$$: string]: string;
2818
+ }
2819
  ): Promise<ImageSize>;
2820
+ getSizeWithHeaders(
2821
  uri: string,
2822
+ headers: {
2823
+ [$$Key$$: string]: string;
2824
+ },
2825
  success: (width: number, height: number) => void,
2826
+ failure?: (error: unknown) => void
2827
  ): void;
2828
+ prefetch(url: string): Promise<boolean>;
2829
+ prefetchWithMetadata(
2830
  url: string,
2831
  queryRootName: string,
2832
+ rootTag?: RootTag | undefined
2833
  ): Promise<boolean>;
2834
+ queryCache(urls: Array<string>): Promise<{
 
 
2835
+ [url: string]: 'memory' | 'disk' | 'disk/memory';
 
 
 
2836
+ }>;
2837
+
 
 
 
 
 
 
 
2838
+ resolveAssetSource(source: ImageSource): ImageResolvedAssetSource | undefined;
 
 
2839
+ }>;
2840
+
 
 
2841
+ export declare type ImageErrorEvent = NativeSyntheticEvent<
2842
+ Readonly<ImageErrorEventData>
2843
+ >;
2844
+
2845
+ declare type ImageErrorEventData = {
2846
+ error: string;
2847
+ };
2848
+
2849
+ declare type ImageIOS = AbstractImageIOS & ImageComponentStaticsIOS;
2850
+
2851
+ export declare type ImageLoadEvent = NativeSyntheticEvent<
2852
+ Readonly<ImageLoadEventData>
2853
+ >;
2854
+
2855
+ declare type ImageLoadEventData = {
2856
  source: {
2857
  height: number;
2858
  width: number;
2859
  uri: string;
2860
  };
2861
+ };
2862
+
2863
+ declare type ImageProgressEventDataIOS = {
2864
  loaded: number;
2865
  total: number;
2866
+ };
2867
+
2868
+ export declare type ImageProgressEventIOS = NativeSyntheticEvent<
2869
+ Readonly<ImageProgressEventDataIOS>
2870
+ >;
2871
+
2872
+ export declare type ImageProps = Readonly<
2873
+ Omit<
2874
+ ImagePropsIOS,
2875
+ keyof (
2876
+ | ImagePropsAndroid
2877
+ | ImagePropsBase
2878
+ | {
2879
+ style?: ImageStyleProp | undefined;
2880
+ }
2881
+ )
2882
+ > &
2883
+ Omit<
2884
+ ImagePropsAndroid,
2885
+ keyof (
2886
+ | ImagePropsBase
 
 
 
2887
+ | {
2888
+ style?: ImageStyleProp | undefined;
2889
+ }
2890
+ )
2891
+ > &
2892
+ Omit<
2893
+ ImagePropsBase,
2894
+ keyof {
2895
+ style?: ImageStyleProp | undefined;
2896
+ }
 
2897
+ > & {
 
 
2898
+ style?: ImageStyleProp | undefined;
2899
+ }
2900
+ >;
2901
+
2902
+ export declare type ImagePropsAndroid = Readonly<{
2903
+ loadingIndicatorSource?: (number | Readonly<ImageURISource>) | undefined;
 
 
 
 
2904
  progressiveRenderingEnabled?: boolean | undefined;
2905
+ fadeDuration?: number | undefined;
2906
+
2907
+ resizeMethod?: ('auto' | 'resize' | 'scale' | 'none') | undefined;
2908
+
2909
+ resizeMultiplier?: number | undefined;
2910
+ }>;
2911
+
2912
+ export declare type ImagePropsBase = Readonly<
2913
+ Omit<
2914
+ Pick<
2915
+ ViewProps,
2916
+ Exclude<
2917
+ keyof ViewProps,
2918
+ keyof Readonly<{
2919
+ style: ViewStyleProp | undefined;
2920
+ }>
2921
+ >
2922
+ >,
2923
+ keyof {
2924
+ accessible?: boolean | undefined;
2925
+
2926
+ internal_analyticTag?: string | undefined;
2927
+
2928
+ accessibilityLabel?: string | undefined;
2929
+
2930
+ 'aria-label'?: string | undefined;
2931
+
2932
+ 'aria-labelledby'?: string | undefined;
2933
+
2934
+ alt?: string | undefined;
2935
+
2936
+ blurRadius?: number | undefined;
2937
+
2938
+ capInsets?: EdgeInsetsProp | undefined;
2939
+
2940
+ crossOrigin?: ('anonymous' | 'use-credentials') | undefined;
2941
+
2942
+ height?: number;
2943
+
2944
+ width?: number;
2945
+
2946
+ onError?: ((event: ImageErrorEvent) => void) | undefined;
2947
+
2948
+ onLayout?: ((event: LayoutChangeEvent) => unknown) | undefined;
2949
+
2950
+ onLoad?: ((event: ImageLoadEvent) => void) | undefined;
2951
+
2952
+ onLoadEnd?: (() => void) | undefined;
2953
+
2954
+ onLoadStart?: (() => void) | undefined;
2955
+
2956
+ source?: ImageSource | undefined;
2957
+
2958
+ referrerPolicy?:
2959
+ | (
2960
+ | 'no-referrer'
2961
+ | 'no-referrer-when-downgrade'
2962
+ | 'origin'
2963
+ | 'origin-when-cross-origin'
2964
+ | 'same-origin'
2965
+ | 'strict-origin'
2966
+ | 'strict-origin-when-cross-origin'
2967
+ | 'unsafe-url'
2968
+ )
2969
+ | undefined;
2970
+
2971
+ resizeMode?: ImageResizeMode | undefined;
2972
+
2973
+ testID?: string | undefined;
2974
+
2975
+ tintColor?: ColorValue;
2976
+
2977
+ src?: string | undefined;
2978
+
2979
+ srcSet?: string | undefined;
2980
+ children?: never;
2981
+ }
2982
+ > & {
2983
+ accessible?: boolean | undefined;
2984
+
2985
+ internal_analyticTag?: string | undefined;
2986
+
2987
+ accessibilityLabel?: string | undefined;
2988
+
2989
+ 'aria-label'?: string | undefined;
2990
+
2991
+ 'aria-labelledby'?: string | undefined;
2992
+
2993
+ alt?: string | undefined;
2994
+
2995
+ blurRadius?: number | undefined;
2996
+
2997
+ capInsets?: EdgeInsetsProp | undefined;
2998
+
2999
+ crossOrigin?: ('anonymous' | 'use-credentials') | undefined;
3000
+
3001
+ height?: number;
3002
+
3003
+ width?: number;
3004
+
3005
+ onError?: ((event: ImageErrorEvent) => void) | undefined;
3006
+
3007
+ onLayout?: ((event: LayoutChangeEvent) => unknown) | undefined;
3008
+
3009
+ onLoad?: ((event: ImageLoadEvent) => void) | undefined;
3010
+
3011
+ onLoadEnd?: (() => void) | undefined;
3012
+
3013
+ onLoadStart?: (() => void) | undefined;
3014
+
3015
+ source?: ImageSource | undefined;
3016
+
3017
+ referrerPolicy?:
3018
+ | (
3019
+ | 'no-referrer'
3020
+ | 'no-referrer-when-downgrade'
3021
+ | 'origin'
3022
+ | 'origin-when-cross-origin'
3023
+ | 'same-origin'
3024
+ | 'strict-origin'
3025
+ | 'strict-origin-when-cross-origin'
3026
+ | 'unsafe-url'
3027
+ )
3028
+ | undefined;
3029
+
3030
+ resizeMode?: ImageResizeMode | undefined;
3031
+
3032
+ testID?: string | undefined;
3033
+
3034
+ tintColor?: ColorValue;
3035
+
3036
+ src?: string | undefined;
3037
+
3038
+ srcSet?: string | undefined;
3039
+ children?: never;
3040
+ }
3041
+ >;
3042
+
3043
+ export declare type ImagePropsIOS = Readonly<{
3044
+ defaultSource?: ImageSource | undefined;
3045
+
3046
  onPartialLoad?: (() => void) | undefined;
3047
+
3048
+ onProgress?: ((event: ImageProgressEventIOS) => void) | undefined;
3049
+ }>;
3050
+
3051
+ declare type ImageResizeMode =
3052
+ | 'center'
3053
  | 'contain'
3054
+ | 'cover'
3055
  | 'repeat'
3056
+ | 'stretch'
3057
  | 'none';
3058
+
 
 
 
 
 
 
 
3059
+ export declare type ImageResolvedAssetSource = ResolvedAssetSource;
3060
+
3061
+ export declare type ImageSize = {
3062
  width: number;
 
 
 
 
 
3063
  height: number;
3064
+ };
3065
+
3066
+ export declare type ImageSource =
3067
+ | number
3068
  | ImageURISource
3069
+ | ReadonlyArray<ImageURISource>;
3070
+
3071
+ export declare type ImageSourcePropType = ImageSource;
3072
+
 
 
 
 
 
 
 
 
3073
+ export declare type ImageStyle = ____ImageStyle_Internal;
3074
+
 
3075
+ declare type ImageStyleProp = ____ImageStyleProp_Internal;
3076
+
 
 
 
 
 
3077
  export declare interface ImageURISource {
3078
+ readonly uri?: string | undefined;
3079
+
3080
+ readonly bundle?: string | undefined;
3081
+
3082
+ readonly method?: string | undefined;
3083
+
3084
+ readonly headers?:
3085
+ | {
3086
+ [$$Key$$: string]: string;
3087
+ }
3088
+ | undefined;
3089
+
3090
+ readonly body?: string | undefined;
3091
+
3092
+ readonly cache?:
3093
+ | ('default' | 'reload' | 'force-cache' | 'only-if-cached')
3094
+ | undefined;
3095
+
3096
+ readonly width?: number | undefined;
3097
+ readonly height?: number | undefined;
3098
+
3099
+ readonly scale?: number | undefined;
3100
  }
3101
+
3102
+ declare type ImageViewNativeComponent =
3103
+ typeof ImageViewNativeComponent_MODULE_EXPORT;
3104
+
3105
+ declare const ImageViewNativeComponent_2: HostComponent<Props>;
3106
+
3107
+ declare const ImageViewNativeComponent_MODULE_EXPORT: typeof ImageViewNativeComponent_2;
3108
+
3109
+ declare type ImageViewNativeComponent_MODULE_EXPORT =
3110
+ typeof ImageViewNativeComponent_MODULE_EXPORT;
3111
+
3112
+ declare type IndicatorSize = number | 'small' | 'large';
3113
+
3114
+ declare type InnerViewInstance = React.ComponentRef<View_3>;
3115
+
3116
+ export declare const InputAccessoryView: typeof InputAccessoryView_2;
3117
+
3118
+ export declare type InputAccessoryView = typeof InputAccessoryView;
3119
+
3120
+ declare const InputAccessoryView_2: React.ComponentType<InputAccessoryViewProps>;
3121
+
3122
+ export declare type InputAccessoryViewProps = Readonly<{
 
3123
+ readonly children: React.ReactNode;
3124
+
3125
  nativeID?: string | undefined;
3126
+ style?: ViewStyleProp | undefined;
3127
+ backgroundColor?: ColorValue | undefined;
3128
+ }>;
3129
+
3130
  export declare type InputModeOptions =
3131
  | 'none'
3132
  | 'text'
3133
  | 'decimal'
 
3135
  | 'tel'
3136
  | 'search'
3137
  | 'email'
3138
  | 'url';
3139
+
3140
+ declare type InputModeOptions_2 =
3141
+ | 'none'
3142
+ | 'text'
3143
+ | 'decimal'
3144
+ | 'numeric'
3145
+ | 'tel'
3146
+ | 'search'
3147
+ | 'email'
3148
+ | 'url';
3149
+
3150
+ declare type InputValue =
3151
+ | null
3152
+ | undefined
 
3153
+ | (RgbaValue | RgbaAnimatedValue | ColorValue);
3154
+
3155
+ declare type Instance = React.ComponentRef<typeof ScrollView>;
3156
+
3157
  declare type Int32 = number;
3158
+
3159
+ export declare const InteractionManager: typeof InteractionManager_2;
3160
+
3161
+ export declare type InteractionManager = typeof InteractionManager;
3162
+
3163
+ declare const InteractionManager_2: typeof InteractionManagerImpl;
3164
+
3165
+ declare const InteractionManagerImpl: {
3166
  Events: {
3167
+ interactionStart: 'interactionStart';
3168
+ interactionComplete: 'interactionComplete';
3169
  };
3170
+
 
 
 
 
3171
+ runAfterInteractions(task: null | undefined | Task_2): {
3172
+ then: <U>(
3173
+ onFulfill?:
3174
+ | (($$PARAM_0$$: void) => (Promise<U> | U) | undefined)
3175
+ | undefined,
3176
+ onReject?: ((error: unknown) => (Promise<U> | U) | undefined) | undefined
3177
+ ) => Promise<U>;
3178
  cancel: () => void;
3179
  };
3180
+
3181
  createInteractionHandle(): Handle;
3182
+
3183
  clearInteractionHandle(handle: Handle): void;
3184
+ addListener: (
3185
+ eventType: string,
3186
+ listener: (...args: any) => unknown,
3187
+ context: unknown
3188
+ ) => EventSubscription;
3189
+
3190
  setDeadline(deadline: number): void;
3191
+ };
3192
+
3193
+ declare type InternalTextInput = (
3194
+ props: Omit<
3195
+ TextInputProps_2,
3196
+ keyof {
3197
+ ref?: React.Ref<TextInputInstance>;
3198
+ }
3199
+ > & {
3200
+ ref?: React.Ref<TextInputInstance>;
3201
+ }
3202
+ ) => React.ReactNode;
3203
+
3204
+ declare type InterpolationConfigType<OutputT extends number | string> =
3205
+ Readonly<
3206
+ Omit<
3207
+ AnimatedNodeConfig,
3208
+ keyof {
3209
+ inputRange: ReadonlyArray<number>;
3210
+ outputRange: ReadonlyArray<OutputT>;
3211
+ easing?: (input: number) => number;
3212
+ extrapolate?: ExtrapolateType;
3213
+ extrapolateLeft?: ExtrapolateType;
3214
+ extrapolateRight?: ExtrapolateType;
3215
+ }
3216
+ > & {
3217
+ inputRange: ReadonlyArray<number>;
3218
+ outputRange: ReadonlyArray<OutputT>;
3219
+ easing?: (input: number) => number;
3220
+ extrapolate?: ExtrapolateType;
3221
+ extrapolateLeft?: ExtrapolateType;
3222
+ extrapolateRight?: ExtrapolateType;
3223
+ }
3224
+ >;
3225
+
3226
+ export declare type IOSKeyboardEvent = Readonly<
3227
+ Omit<
3228
+ BaseKeyboardEvent,
3229
+ keyof {
3230
+ startCoordinates: KeyboardMetrics;
3231
+ isEventFromThisApp: boolean;
3232
+ }
3233
+ > & {
3234
+ startCoordinates: KeyboardMetrics;
3235
+ isEventFromThisApp: boolean;
3236
+ }
3237
+ >;
3238
+
3239
+ declare type IOSPlatform = {
3240
+ OS: 'ios';
3241
+ get Version(): string;
3242
+ get constants(): {
3243
+ forceTouchAvailable: boolean;
3244
+ interfaceIdiom: string;
3245
+ isTesting: boolean;
3246
+ isDisableAnimations?: boolean;
3247
+ osVersion: string;
3248
+ reactNativeVersion: {
3249
+ major: number;
3250
+ minor: number;
3251
+ patch: number;
3252
+ prerelease: string | undefined;
3253
+ };
3254
+ systemName: string;
3255
+ isMacCatalyst?: boolean;
3256
+ };
3257
+ get isPad(): boolean;
3258
+ get isTV(): boolean;
3259
+ get isVision(): boolean;
3260
+ get isTesting(): boolean;
3261
+ get isDisableAnimations(): boolean;
3262
+ get isMacCatalyst(): boolean;
3263
+ select: <T>(spec: PlatformSelectSpec<T>) => T;
3264
+ };
3265
+
3266
+ declare type IOSProps = Readonly<{
3267
+ hasTVPreferredFocus?: boolean | undefined;
3268
+ }>;
3269
+
3270
  declare interface IPerformanceLogger {
3271
  addTimespan(
3272
  key: string,
3273
  startTime: number,
 
3279
  clear(): void;
3280
  clearCompleted(): void;
3281
  close(): void;
3282
  currentTimestamp(): number;
3283
+ getExtras(): Readonly<{
3284
+ [key: string]: ExtraValue | undefined;
3285
+ }>;
3286
+ getPoints(): Readonly<{
3287
+ [key: string]: number | undefined;
3288
+ }>;
3289
+ getPointExtras(): Readonly<{
3290
+ [key: string]: Extras | undefined;
3291
+ }>;
3292
+ getTimespans(): Readonly<{
3293
+ [key: string]: Timespan | undefined;
3294
+ }>;
3295
  hasTimespan(key: string): boolean;
3296
  isClosed(): boolean;
3297
  logEverything(): void;
3298
  markPoint(key: string, timestamp?: number, extras?: Extras): void;
3299
+ removeExtra(key: string): ExtraValue | undefined;
3300
  setExtra(key: string, value: ExtraValue): void;
3301
  startTimespan(key: string, timestamp?: number, extras?: Extras): void;
3302
  stopTimespan(key: string, timestamp?: number, extras?: Extras): void;
3303
  }
3304
+
3305
  declare function isEnabled(): boolean;
3306
+
3307
+ export declare class Keyboard {
3308
+ constructor();
3309
+ addListener<K extends keyof KeyboardEventDefinitions>(
 
3310
+ eventType: K,
 
3311
+ listener: (...$$REST$$: KeyboardEventDefinitions[K]) => unknown,
3312
+ context?: unknown
3313
+ ): EventSubscription;
3314
+ removeAllListeners<K extends keyof KeyboardEventDefinitions>(
 
3315
+ eventType: null | undefined | K
3316
+ ): void;
3317
+ dismiss(): void;
3318
+ isVisible(): boolean;
3319
+ metrics(): null | undefined | KeyboardMetrics;
3320
+ scheduleLayoutAnimation(event: KeyboardEvent_2): void;
3321
  }
3322
+
3323
+ export declare class KeyboardAvoidingView extends React.Component<
 
3324
+ KeyboardAvoidingViewProps,
3325
+ State_3
3326
+ > {
3327
+ viewRef: {
3328
+ current: React.ComponentRef<typeof View> | null;
3329
+ };
3330
+ constructor(props: KeyboardAvoidingViewProps);
3331
+ componentDidUpdate(_: KeyboardAvoidingViewProps, prevState: State_3): void;
3332
+ componentDidMount(): void;
3333
+ componentWillUnmount(): void;
3334
+ render(): React.ReactNode;
3335
  }
3336
+
3337
+ export declare type KeyboardAvoidingViewProps = Readonly<
3338
+ Omit<
3339
+ ViewProps,
3340
+ keyof {
3341
+ behavior?: ('height' | 'position' | 'padding') | undefined;
3342
+
3343
+ contentContainerStyle?: ViewStyleProp | undefined;
3344
+
3345
+ enabled?: boolean | undefined;
3346
+
3347
+ keyboardVerticalOffset?: number;
3348
+ }
3349
+ > & {
3350
+ behavior?: ('height' | 'position' | 'padding') | undefined;
3351
+
3352
+ contentContainerStyle?: ViewStyleProp | undefined;
3353
+
3354
+ enabled?: boolean | undefined;
3355
+
3356
+ keyboardVerticalOffset?: number;
3357
+ }
3358
+ >;
3359
+
3360
+ declare type KeyboardEvent_2 = AndroidKeyboardEvent | IOSKeyboardEvent;
3361
  export {KeyboardEvent_2 as KeyboardEvent};
3362
+
3363
+ declare type KeyboardEventDefinitions = {
3364
+ keyboardWillShow: [KeyboardEvent_2];
3365
+ keyboardDidShow: [KeyboardEvent_2];
3366
+ keyboardWillHide: [KeyboardEvent_2];
3367
+ keyboardDidHide: [KeyboardEvent_2];
3368
+ keyboardWillChangeFrame: [KeyboardEvent_2];
3369
+ keyboardDidChangeFrame: [KeyboardEvent_2];
3370
+ };
3371
+
3372
  export declare type KeyboardEventEasing =
3373
  | 'easeIn'
3374
  | 'easeInEaseOut'
3375
  | 'easeOut'
3376
  | 'linear'
3377
  | 'keyboard';
3378
+
 
 
 
3379
+ export declare type KeyboardEventName = keyof KeyboardEventDefinitions;
3380
+
 
 
 
 
 
 
3381
+ export declare type KeyboardMetrics = Readonly<{
3382
  screenX: number;
3383
  screenY: number;
3384
  width: number;
3385
  height: number;
3386
+ }>;
3387
+
 
 
 
 
 
 
 
 
 
3388
+ declare type KeyboardType =
3389
  | 'default'
3390
+ | 'email-address'
3391
+ | 'numeric'
3392
+ | 'phone-pad'
3393
  | 'number-pad'
3394
  | 'decimal-pad'
3395
+ | 'url';
3396
+
3397
+ declare type KeyboardType_2 =
3398
+ | 'default'
3399
  | 'email-address'
3400
+ | 'numeric'
3401
  | 'phone-pad'
3402
+ | 'number-pad'
3403
+ | 'decimal-pad'
3404
  | 'url';
3405
+
3406
+ declare type KeyboardTypeAndroid = 'visible-password';
3407
+
3408
+ declare type KeyboardTypeAndroid_2 = 'visible-password';
3409
+
3410
+ declare type KeyboardTypeIOS =
3411
  | 'ascii-capable'
3412
  | 'numbers-and-punctuation'
3413
  | 'name-phone-pad'
3414
  | 'twitter'
3415
+ | 'web-search'
3416
+ | 'ascii-capable-number-pad';
3417
+
3418
+ declare type KeyboardTypeIOS_2 =
3419
+ | 'ascii-capable'
3420
+ | 'numbers-and-punctuation'
3421
+ | 'name-phone-pad'
3422
+ | 'twitter'
3423
+ | 'web-search'
3424
+ | 'ascii-capable-number-pad';
3425
+
3426
  export declare type KeyboardTypeOptions =
3427
  | KeyboardType
3428
+ | KeyboardTypeIOS
3429
+ | KeyboardTypeAndroid;
3430
+
3431
+ declare type KeyboardTypeOptions_2 =
3432
+ | KeyboardType_2
3433
+ | KeyboardTypeIOS_2
3434
+ | KeyboardTypeAndroid_2;
3435
+
3436
+ export declare const LayoutAnimation: typeof LayoutAnimation_2;
3437
+
3438
+ export declare type LayoutAnimation = typeof LayoutAnimation;
3439
+
3440
+ declare const LayoutAnimation_2: {
3441
+ configureNext: typeof configureNext;
3442
+
3443
+ create: typeof create;
3444
+ Types: LayoutAnimationTypes;
3445
+ Properties: LayoutAnimationProperties;
3446
+ checkConfig(...args: Array<unknown>): void;
3447
+ Presets: typeof Presets;
3448
+ easeInEaseOut: (onAnimationDidEnd?: OnAnimationDidEndCallback) => void;
3449
+ linear: (onAnimationDidEnd?: OnAnimationDidEndCallback) => void;
3450
+ spring: (onAnimationDidEnd?: OnAnimationDidEndCallback) => void;
3451
+ setEnabled: typeof setEnabled;
3452
+ };
3453
+
3454
+ export declare type LayoutAnimationAnim = Readonly<{
3455
+ duration?: number;
3456
+ delay?: number;
3457
+ springDamping?: number;
3458
+ initialVelocity?: number;
3459
+ type?: LayoutAnimationType;
3460
+ property?: LayoutAnimationProperty;
3461
+ }>;
3462
+
3463
+ export declare type LayoutAnimationConfig = LayoutAnimationConfig_2;
3464
+
 
 
 
 
 
3465
+ declare type LayoutAnimationConfig_2 = Readonly<{
 
 
3466
  duration: number;
3467
+ create?: LayoutAnimationAnim;
3468
+ update?: LayoutAnimationAnim;
3469
+ delete?: LayoutAnimationAnim;
3470
+ }>;
3471
+
3472
+ export declare type LayoutAnimationProperties = Readonly<{
3473
  [prop in LayoutAnimationProperty]: prop;
3474
+ }>;
3475
+
3476
  export declare type LayoutAnimationProperty =
3477
  | 'opacity'
3478
  | 'scaleX'
3479
  | 'scaleY'
3480
  | 'scaleXY';
3481
+
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3482
  export declare type LayoutAnimationType =
3483
  | 'spring'
3484
  | 'linear'
3485
  | 'easeInEaseOut'
3486
  | 'easeIn'
3487
  | 'easeOut'
3488
  | 'keyboard';
3489
+
3490
+ export declare type LayoutAnimationTypes = Readonly<{
3491
  [type in LayoutAnimationType]: type;
 
 
 
3492
  }>;
3493
+
3494
+ export declare type LayoutChangeEvent = NativeSyntheticEvent<
3495
+ Readonly<{
3496
+ layout: LayoutRectangle;
3497
+ }>
3498
+ >;
3499
+
3500
+ export declare type LayoutConformanceProps = Readonly<{
3501
  mode: 'strict' | 'compatibility';
3502
+ children: React.ReactNode;
3503
+ }>;
3504
+
3505
+ export declare type LayoutRectangle = Readonly<{
3506
  x: number;
3507
  y: number;
3508
  width: number;
3509
  height: number;
3510
+ }>;
3511
+
3512
+ export declare const Linking: typeof Linking_2;
3513
+
3514
+ export declare type Linking = typeof Linking;
3515
+
3516
+ declare const Linking_2: LinkingImpl;
3517
+
3518
+ declare type LinkingEventDefinitions = {
3519
+ url: [
3520
+ {
3521
+ url: string;
3522
+ },
3523
+ ];
3524
+ };
3525
+
3526
+ declare class LinkingImpl extends NativeEventEmitter<LinkingEventDefinitions> {
3527
+ constructor();
3528
+ addEventListener<K extends keyof LinkingEventDefinitions>(
3529
+ eventType: K,
 
3530
+ listener: (...$$REST$$: LinkingEventDefinitions[K]) => unknown
3531
+ ): EventSubscription;
3532
+ openURL(url: string): Promise<void>;
3533
  canOpenURL(url: string): Promise<boolean>;
 
3534
  openSettings(): Promise<void>;
3535
+ getInitialURL(): Promise<null | undefined | string>;
3536
  sendIntent(
3537
  action: string,
3538
+ extras?: Array<{
3539
+ key: string;
3540
+ value: string | number | boolean;
3541
+ }>
3542
  ): Promise<void>;
3543
  }
3544
+
3545
+ export {ListRenderItem};
3546
+
3547
+ export {ListRenderItemInfo};
3548
+
3549
+ export declare const LogBox: ILogBox;
3550
+
3551
+ export declare type LogBox = typeof LogBox;
3552
+
3553
+ export declare type LogData = Readonly<{
3554
+ level: LogLevel;
3555
+ message: Message;
3556
+ category: Category;
3557
+ componentStack: ComponentStack;
3558
+ componentStackType: ComponentStackType | null;
 
3559
+ stack?: string;
3560
+ }>;
3561
+
3562
+ declare type LogLevel = 'warn' | 'error' | 'fatal' | 'syntax';
3563
+
3564
+ declare const loop: (
3565
+ animation: CompositeAnimation,
3566
+ $$PARAM_1$$: LoopAnimationConfig
3567
+ ) => CompositeAnimation;
3568
+
3569
+ declare const loop_2: typeof AnimatedImplementation_MODULE_EXPORT.loop;
3570
+
3571
+ declare type loop_2 = typeof loop_2;
3572
+
3573
+ declare type LoopAnimationConfig = {
3574
+ iterations: number;
3575
+ resetBeforeIteration?: boolean;
3576
+ };
3577
+
3578
+ declare type MacOSPlatform = {
3579
+ OS: 'macos';
3580
+ get Version(): string;
3581
+ get constants(): {
3582
+ isTesting: boolean;
3583
+ osVersion: string;
3584
+ reactNativeVersion: {
3585
+ major: number;
3586
+ minor: number;
3587
+ patch: number;
3588
+ prerelease: number | undefined;
3589
+ };
3590
+ systemName: string;
3591
+ };
3592
+ get isTV(): boolean;
3593
+ get isVision(): boolean;
3594
+ get isTesting(): boolean;
3595
+ get isDisableAnimations(): boolean;
3596
+ select: <T>(spec: PlatformSelectSpec<T>) => T;
3597
+ };
3598
+
3599
+ declare type Mapping =
3600
+ | {
3601
+ [key: string]: Mapping;
3602
+ }
3603
+ | AnimatedValue
3604
+ | AnimatedValueXY;
3605
+
 
 
 
 
 
 
3606
  export declare type MeasureInWindowOnSuccessCallback = (
3607
  x: number,
3608
  y: number,
3609
  width: number,
3610
  height: number
3611
  ) => void;
3612
+
3613
+ declare type MeasureInWindowOnSuccessCallback_2 = (
3614
+ x: number,
3615
+ y: number,
3616
+ width: number,
3617
+ height: number
3618
+ ) => void;
3619
+
3620
  export declare type MeasureLayoutOnSuccessCallback = (
3621
  left: number,
3622
  top: number,
3623
  width: number,
3624
  height: number
3625
  ) => void;
3626
+
3627
+ declare type MeasureLayoutOnSuccessCallback_2 = (
3628
+ left: number,
3629
+ top: number,
3630
+ width: number,
3631
+ height: number
3632
+ ) => void;
3633
+
3634
  export declare type MeasureOnSuccessCallback = (
3635
  x: number,
3636
  y: number,
3637
  width: number,
3638
  height: number,
3639
  pageX: number,
3640
  pageY: number
3641
  ) => void;
3642
+
3643
+ declare type MeasureOnSuccessCallback_2 = (
3644
+ x: number,
3645
+ y: number,
3646
+ width: number,
3647
+ height: number,
3648
+ pageX: number,
3649
+ pageY: number
3650
+ ) => void;
3651
+
3652
+ declare type Message = Readonly<{
3653
+ content: string;
3654
+ substitutions: ReadonlyArray<
3655
+ Readonly<{
3656
+ length: number;
3657
+ offset: number;
3658
+ }>
3659
+ >;
3660
+ }>;
3661
+
3662
+ export declare const Modal: typeof Wrapper_2;
3663
+
3664
+ export declare type Modal = typeof Modal;
3665
+
3666
+ export declare type ModalBaseProps = {
3667
+ animated?: boolean;
3668
+
3669
+ animationType?: ('none' | 'slide' | 'fade') | undefined;
3670
+
3671
  transparent?: boolean | undefined;
3672
+
3673
  visible?: boolean | undefined;
3674
+
3675
+ onRequestClose?: DirectEventHandler<null> | undefined;
3676
+
3677
+ onShow?: DirectEventHandler<null> | undefined;
3678
+
3679
+ backdropColor?: ColorValue;
3680
+
3681
+ modalRef?: React.Ref<PublicModalInstance>;
3682
+ };
3683
+
3684
+ export declare type ModalProps = Omit<
3685
+ ModalBaseProps,
3686
+ keyof (ModalPropsIOS | ModalPropsAndroid | ViewProps | {})
3687
+ > &
3688
+ Omit<ModalPropsIOS, keyof (ModalPropsAndroid | ViewProps | {})> &
3689
+ Omit<ModalPropsAndroid, keyof (ViewProps | {})> &
3690
+ Omit<ViewProps, keyof {}> & {};
3691
+
3692
+ export declare type ModalPropsAndroid = {
3693
  hardwareAccelerated?: boolean | undefined;
3694
+
3695
  statusBarTranslucent?: boolean | undefined;
3696
+
3697
  navigationBarTranslucent?: boolean | undefined;
3698
+ };
3699
+
3700
+ export declare type ModalPropsIOS = {
3701
  presentationStyle?:
 
 
 
3702
+ | ('fullScreen' | 'pageSheet' | 'formSheet' | 'overFullScreen')
3703
  | undefined;
3704
+
3705
  supportedOrientations?:
3706
+ | ReadonlyArray<
3707
  | 'portrait'
3708
  | 'portrait-upside-down'
3709
  | 'landscape'
3710
  | 'landscape-left'
3711
  | 'landscape-right'
3712
  >
3713
  | undefined;
3714
+
3715
  onDismiss?: (() => void) | undefined;
3716
+
3717
+ onOrientationChange?: DirectEventHandler<OrientationChangeEvent> | undefined;
 
3718
+ };
3719
+
3720
+ declare type ModalRefProps = Readonly<{
3721
+ ref?: React.Ref<PublicModalInstance>;
3722
+ }>;
3723
+
3724
+ declare type Module = {};
3725
+
3726
+ declare const modulo: (a: AnimatedNode, modulus: number) => AnimatedModulo;
3727
+
3728
+ declare const modulo_2: typeof AnimatedImplementation_MODULE_EXPORT.modulo;
3729
+
3730
+ declare type modulo_2 = typeof modulo_2;
3731
+
3732
+ declare type MouseEvent_2 = NativeSyntheticEvent<
3733
+ Readonly<{
3734
+ clientX: number;
3735
+ clientY: number;
3736
+ pageX: number;
3737
+ pageY: number;
3738
+ timestamp: number;
3739
+ }>
3740
+ >;
3741
  export {MouseEvent_2 as MouseEvent};
3742
+
3743
+ declare type MouseEventProps = Readonly<{
3744
+ onMouseEnter?: ((event: MouseEvent_2) => void) | undefined;
3745
+ onMouseLeave?: ((event: MouseEvent_2) => void) | undefined;
3746
+ }>;
3747
+
3748
+ declare const multiply: (
3749
+ a: AnimatedNode | number,
3750
+ b: AnimatedNode | number
3751
+ ) => AnimatedMultiplication;
3752
+
3753
+ declare const multiply_2: typeof AnimatedImplementation_MODULE_EXPORT.multiply;
3754
+
3755
+ declare type multiply_2 = typeof multiply_2;
3756
+
3757
+ export declare const NativeAppEventEmitter: typeof RCTNativeAppEventEmitter;
3758
+
3759
+ export declare type NativeAppEventEmitter = typeof NativeAppEventEmitter;
3760
+
3761
+ declare type NativeColorValue = symbol & {
3762
+ __NativeColorValue__: string;
3763
+ };
3764
+
3765
  declare type NativeComponentType<T> = HostComponent<T>;
3766
+
3767
+ declare const NativeDeviceInfo: {
3768
+ getConstants(): DeviceInfoConstants;
3769
+ };
3770
+
3771
+ declare const NativeDeviceInfo_MODULE_EXPORT: typeof NativeDeviceInfo_MODULE_EXPORT_2;
3772
+
3773
+ declare type NativeDeviceInfo_MODULE_EXPORT =
3774
+ typeof NativeDeviceInfo_MODULE_EXPORT;
3775
+
3776
+ declare const NativeDeviceInfo_MODULE_EXPORT_2: typeof NativeDeviceInfo;
3777
+
3778
+ declare type NativeDeviceInfo_MODULE_EXPORT_2 =
3779
+ typeof NativeDeviceInfo_MODULE_EXPORT_2;
3780
+
3781
+ export declare const NativeDialogManagerAndroid: typeof NativeDialogManagerAndroid_MODULE_EXPORT;
3782
+
3783
+ export declare type NativeDialogManagerAndroid =
3784
+ typeof NativeDialogManagerAndroid;
3785
+
3786
+ declare const NativeDialogManagerAndroid_MODULE_EXPORT: null | undefined | Spec;
3787
+
3788
+ declare type NativeDialogManagerAndroid_MODULE_EXPORT =
3789
+ typeof NativeDialogManagerAndroid_MODULE_EXPORT;
3790
+
3791
+ export declare class NativeEventEmitter<
3792
+ TEventToArgsMap extends Readonly<
3793
+ Record<string, ReadonlyArray<UnsafeObject_2>>
3794
+ > = Readonly<Record<string, ReadonlyArray<UnsafeObject_2>>>,
3795
+ > implements IEventEmitter<TEventToArgsMap>
3796
+ {
3797
+ constructor(nativeModule: null | undefined | NativeModule);
3798
+ addListener<TEvent extends keyof TEventToArgsMap>(
3799
+ eventType: TEvent,
3800
+ listener: (...args: TEventToArgsMap[TEvent]) => unknown,
3801
+ context?: unknown
3802
+ ): EventSubscription;
3803
+ emit<TEvent extends keyof TEventToArgsMap>(
3804
+ eventType: TEvent,
3805
+ ...args: TEventToArgsMap[TEvent]
3806
+ ): void;
3807
+ removeAllListeners<TEvent extends keyof TEventToArgsMap>(
3808
+ eventType?: null | undefined | TEvent
3809
+ ): void;
3810
+ listenerCount<TEvent extends keyof TEventToArgsMap>(
3811
+ eventType: TEvent
3812
+ ): number;
3813
  }
3814
+
3815
+ export declare type NativeEventSubscription = EventSubscription;
3816
+
 
3817
  export declare interface NativeMethods {
3818
+ blur(): void;
3819
+
3820
+ focus(): void;
3821
+
3822
  measure(callback: MeasureOnSuccessCallback): void;
3823
+
3824
  measureInWindow(callback: MeasureInWindowOnSuccessCallback): void;
3825
+
3826
  measureLayout(
3827
+ relativeToNativeNode: number | HostInstance,
3828
  onSuccess: MeasureLayoutOnSuccessCallback,
3829
  onFail?: () => void
3830
  ): void;
3831
+
3832
+ setNativeProps(nativeProps: {}): void;
 
 
3833
  }
3834
+
 
3835
+ declare interface NativeModule {
3836
+ addListener(eventType: string): void;
3837
+ removeListeners(count: number): void;
 
 
 
 
3838
  }
3839
+
3840
+ export declare const NativeModules: typeof NativeModules_2;
3841
+
3842
+ export declare type NativeModules = typeof NativeModules;
3843
+
3844
+ declare let NativeModules_2: {
3845
+ [moduleName: string]: any;
3846
+ };
3847
+
3848
  export declare interface NativeMouseEvent extends NativeUIEvent {
3849
  readonly screenX: number;
3850
+
3851
  readonly screenY: number;
3852
+
3853
  readonly pageX: number;
3854
+
3855
  readonly pageY: number;
3856
+
3857
  readonly clientX: number;
3858
+
3859
  readonly clientY: number;
3860
+
3861
  readonly x: number;
3862
+
3863
  readonly y: number;
3864
+
3865
  readonly ctrlKey: boolean;
3866
+
3867
  readonly shiftKey: boolean;
3868
+
3869
  readonly altKey: boolean;
3870
+
3871
  readonly metaKey: boolean;
3872
+
3873
  readonly button: number;
3874
+
3875
  readonly buttons: number;
3876
+
3877
  readonly relatedTarget: null | number | HostInstance;
3878
+
3879
  readonly offsetX: number;
3880
+
3881
  readonly offsetY: number;
3882
  }
3883
+
3884
  export declare interface NativePointerEvent extends NativeMouseEvent {
3885
  readonly pointerId: number;
3886
+
3887
  readonly width: number;
3888
+
3889
  readonly height: number;
3890
+
3891
  readonly pressure: number;
3892
+
3893
  readonly tangentialPressure: number;
3894
+
3895
  readonly tiltX: number;
3896
+
3897
  readonly tiltY: number;
3898
+
3899
  readonly twist: number;
3900
+
3901
  readonly pointerType: string;
3902
+
3903
  readonly isPrimary: boolean;
3904
  }
3905
+
3906
+ declare type NativeProps = Readonly<
3907
+ Omit<
3908
+ ViewProps,
3909
+ keyof {
3910
+ resizeMode?: ImageResizeMode | undefined;
3911
+ src?:
3912
+ | ReadonlyArray<
3913
+ | Readonly<{
3914
+ uri?: string | undefined;
3915
+ }>
3916
+ | undefined
3917
+ >
3918
+ | undefined;
3919
+ tintColor?: ColorValue | undefined;
3920
+ headers?:
3921
+ | {
3922
+ [$$Key$$: string]: string;
3923
+ }
3924
+ | undefined;
3925
+ }
3926
+ > & {
3927
+ resizeMode?: ImageResizeMode | undefined;
3928
+ src?:
3929
+ | ReadonlyArray<
3930
+ | Readonly<{
3931
+ uri?: string | undefined;
3932
+ }>
3933
+ | undefined
3934
+ >
3935
+ | undefined;
3936
+ tintColor?: ColorValue | undefined;
3937
+ headers?:
3938
+ | {
3939
+ [$$Key$$: string]: string;
3940
+ }
3941
+ | undefined;
3942
+ }
3943
+ >;
3944
+
3945
+ declare type NativeProps_2 = Readonly<
3946
+ Omit<
3947
+ ViewProps,
3948
+ keyof {
3949
+ styleAttr?: string;
3950
+ typeAttr?: string;
3951
+ indeterminate: boolean;
3952
+ progress?: WithDefault<Double, 0>;
3953
+ animating?: WithDefault<boolean, true>;
3954
+ color?: ColorValue | undefined;
3955
+ testID?: WithDefault<string, ''>;
3956
+ }
3957
+ > & {
3958
+ styleAttr?: string;
3959
+ typeAttr?: string;
3960
+ indeterminate: boolean;
3961
+ progress?: WithDefault<Double, 0>;
3962
+ animating?: WithDefault<boolean, true>;
3963
+ color?: ColorValue | undefined;
3964
+ testID?: WithDefault<string, ''>;
3965
+ }
3966
+ >;
3967
+
3968
+ declare type NativeProps_3 = Readonly<
3969
+ Omit<
3970
+ ViewProps,
3971
+ keyof {
3972
+ disabled?: WithDefault<boolean, false>;
3973
+ value?: WithDefault<boolean, false>;
3974
+ tintColor?: ColorValue | undefined;
3975
+ onTintColor?: ColorValue | undefined;
3976
+ thumbTintColor?: ColorValue | undefined;
3977
+ thumbColor?: ColorValue | undefined;
3978
+ trackColorForFalse?: ColorValue | undefined;
3979
+ trackColorForTrue?: ColorValue | undefined;
3980
+ onChange?: BubblingEventHandler<SwitchChangeEvent_2> | undefined;
3981
+ }
3982
+ > & {
3983
+ disabled?: WithDefault<boolean, false>;
3984
+ value?: WithDefault<boolean, false>;
3985
+ tintColor?: ColorValue | undefined;
3986
+ onTintColor?: ColorValue | undefined;
3987
+ thumbTintColor?: ColorValue | undefined;
3988
+ thumbColor?: ColorValue | undefined;
3989
+ trackColorForFalse?: ColorValue | undefined;
3990
+ trackColorForTrue?: ColorValue | undefined;
3991
+ onChange?: BubblingEventHandler<SwitchChangeEvent_2> | undefined;
3992
+ }
3993
+ >;
3994
+
3995
+ declare type NativeProps_4 = Readonly<
3996
+ Omit<
3997
+ ViewProps,
3998
+ keyof {
3999
+ disabled?: WithDefault<boolean, false>;
4000
+ enabled?: WithDefault<boolean, true>;
4001
+ thumbColor?: ColorValue | undefined;
4002
+ trackColorForFalse?: ColorValue | undefined;
4003
+ trackColorForTrue?: ColorValue | undefined;
4004
+ value?: WithDefault<boolean, false>;
4005
+ on?: WithDefault<boolean, false>;
4006
+ thumbTintColor?: ColorValue | undefined;
4007
+ trackTintColor?: ColorValue | undefined;
4008
+ onChange?: BubblingEventHandler<SwitchChangeEvent_3>;
4009
+ }
4010
+ > & {
4011
+ disabled?: WithDefault<boolean, false>;
4012
+ enabled?: WithDefault<boolean, true>;
4013
+ thumbColor?: ColorValue | undefined;
4014
+ trackColorForFalse?: ColorValue | undefined;
4015
+ trackColorForTrue?: ColorValue | undefined;
4016
+ value?: WithDefault<boolean, false>;
4017
+ on?: WithDefault<boolean, false>;
4018
+ thumbTintColor?: ColorValue | undefined;
4019
+ trackTintColor?: ColorValue | undefined;
4020
+ onChange?: BubblingEventHandler<SwitchChangeEvent_3>;
4021
+ }
4022
+ >;
4023
+
4024
+ declare type NativeResponseType = 'base64' | 'blob' | 'text';
4025
+
4026
+ declare type NativeScrollEvent = Readonly<{
4027
  contentInset: NativeScrollRectangle;
4028
  contentOffset: NativeScrollPoint;
4029
  contentSize: NativeScrollSize;
4030
  layoutMeasurement: NativeScrollSize;
4031
+ velocity?: NativeScrollVelocity;
4032
+ zoomScale?: number;
4033
+ responderIgnoreScroll?: boolean;
4034
+
4035
+ targetContentOffset?: NativeScrollPoint;
4036
+ }>;
4037
+
4038
+ declare type NativeScrollPoint = Readonly<{
 
4039
  y: number;
 
 
 
4040
+ x: number;
4041
+ }>;
4042
+
4043
+ declare type NativeScrollRectangle = Readonly<{
4044
  bottom: number;
4045
+ left: number;
4046
  right: number;
4047
+ top: number;
4048
+ }>;
4049
+
4050
+ declare type NativeScrollSize = Readonly<{
4051
  height: number;
4052
  width: number;
4053
+ }>;
4054
+
4055
+ declare type NativeScrollVelocity = Readonly<{
 
4056
  y: number;
4057
+ x: number;
4058
+ }>;
4059
+
4060
+ export declare type NativeSyntheticEvent<T> = Readonly<{
4061
+ bubbles: boolean | undefined;
4062
+ cancelable: boolean | undefined;
4063
+ currentTarget: number | HostInstance;
4064
+ defaultPrevented: boolean | undefined;
4065
+ dispatchConfig: Readonly<{
4066
+ registrationName: string;
4067
+ }>;
4068
+ eventPhase: number | undefined;
4069
+ preventDefault: () => void;
4070
+ isDefaultPrevented: () => boolean;
4071
+ stopPropagation: () => void;
4072
+ isPropagationStopped: () => boolean;
4073
+ isTrusted: boolean | undefined;
4074
+ nativeEvent: T;
4075
+ persist: () => void;
4076
+ target: (number | undefined) | HostInstance;
4077
+ timeStamp: number;
4078
+ type: string | undefined;
4079
+ }>;
4080
+
4081
+ declare const NativeText: HostComponent<NativeTextProps>;
4082
+
4083
+ declare type NativeText = typeof NativeText;
4084
+
4085
+ declare type NativeTextProps = Readonly<
4086
+ Omit<
4087
+ TextProps,
4088
+ keyof {
4089
+ isHighlighted?: boolean | undefined;
4090
+ selectionColor?: ProcessedColorValue | undefined;
4091
+ onClick?: ((event: GestureResponderEvent) => unknown) | undefined;
4092
+ isPressable?: boolean | undefined;
4093
+ }
4094
+ > & {
4095
+ isHighlighted?: boolean | undefined;
4096
+ selectionColor?: ProcessedColorValue | undefined;
4097
+ onClick?: ((event: GestureResponderEvent) => unknown) | undefined;
4098
+ isPressable?: boolean | undefined;
4099
+ }
4100
+ >;
4101
+
4102
+ export declare type NativeTouchEvent = Readonly<{
4103
+ changedTouches: ReadonlyArray<NativeTouchEvent>;
4104
+
4105
+ force?: number;
4106
+
4107
+ identifier: number;
4108
+
4109
  locationX: number;
4110
+
4111
  locationY: number;
4112
+
4113
  pageX: number;
4114
+
4115
  pageY: number;
4116
+
4117
+ target: number | undefined;
4118
+
4119
  timestamp: number;
4120
+
4121
+ touches: ReadonlyArray<NativeTouchEvent>;
4122
+ }>;
4123
+
4124
+ declare type NativeType = HostComponent<NativeProps_4>;
4125
+
4126
  export declare interface NativeUIEvent {
4127
  readonly detail: number;
4128
  }
4129
+
4130
+ declare const NativeVirtualText: HostComponent<NativeTextProps>;
4131
+
4132
+ declare type NativeVirtualText = typeof NativeVirtualText;
4133
+
4134
+ export declare const Networking: typeof RCTNetworking;
4135
+
4136
+ export declare type Networking = typeof Networking;
4137
+
4138
+ declare type NonAnimatedProps =
4139
+ | 'ref'
4140
+ | 'innerViewRef'
4141
+ | 'scrollViewRef'
4142
+ | 'testID'
4143
+ | 'disabled'
4144
+ | 'accessibilityLabel';
4145
+
4146
+ declare type Nullable = void | null;
4147
+
4148
+ declare type OnAnimationDidEndCallback = () => void;
4149
+
4150
+ declare type OnAnimationDidFailCallback = () => void;
4151
+
4152
+ declare type OptionalPlatformSelectSpec<T> = {[_key in PlatformOSType]?: T};
4153
+
4154
+ declare type OptionalProps<ItemT> = {
4155
+ renderItem?: ListRenderItem<ItemT> | undefined;
4156
+
4157
+ columnWrapperStyle?: ViewStyleProp;
4158
+
4159
+ extraData?: any;
4160
+
4161
+ getItemLayout?: (
4162
+ data: Readonly<ArrayLike<ItemT>> | undefined,
4163
+ index: number
4164
+ ) => {
4165
+ length: number;
4166
+ offset: number;
4167
+ index: number;
4168
+ };
4169
+
4170
+ horizontal?: boolean | undefined;
4171
+
4172
+ initialNumToRender?: number | undefined;
4173
+
4174
+ initialScrollIndex?: number | undefined;
4175
+
4176
+ inverted?: boolean | undefined;
4177
+
4178
+ keyExtractor?: ((item: ItemT, index: number) => string) | undefined;
4179
+
4180
+ numColumns?: number;
4181
+
4182
+ removeClippedSubviews?: boolean;
4183
+
4184
+ fadingEdgeLength?: number | undefined;
4185
+
4186
+ strictMode?: boolean;
4187
+ };
4188
+
4189
+ declare type OptionalProps_2<ItemT, SectionT = DefaultSectionT> = {
4190
+ renderItem?: SectionListRenderItem<ItemT, SectionT>;
4191
+
4192
+ extraData?: any;
4193
+
4194
+ initialNumToRender?: number | undefined;
4195
+
4196
+ inverted?: boolean | undefined;
4197
+
4198
+ keyExtractor?: ((item: ItemT, index: number) => string) | undefined;
4199
+
4200
+ onEndReached?: ((info: {distanceFromEnd: number}) => void) | undefined;
4201
+
4202
+ removeClippedSubviews?: boolean;
4203
+ };
4204
+
4205
+ declare type Options = Readonly<{
4206
+ interfaceOnly?: boolean;
4207
+ paperComponentName?: string;
4208
+ paperComponentNameDeprecated?: string;
4209
+ excludedPlatforms?: ReadonlyArray<'iOS' | 'android'>;
4210
+ }>;
4211
+
4212
+ declare type Options_2<T = string> = Readonly<{
4213
+ supportedCommands: ReadonlyArray<T>;
4214
+ }>;
4215
+
4216
+ declare type OrientationChangeEvent = Readonly<{
4217
+ orientation: 'portrait' | 'landscape';
4218
+ }>;
4219
+
4220
+ export declare const PanResponder: typeof PanResponder_2;
4221
+
4222
+ export declare type PanResponder = typeof PanResponder;
4223
+
4224
+ declare const PanResponder_2: {
4225
+ create(config: PanResponderCallbacks): {
4226
+ getInteractionHandle: () => number | undefined;
4227
+ panHandlers: GestureResponderHandlerMethods;
4228
+ };
4229
+ };
4230
+
4231
+ export declare type PanResponderCallbacks = Readonly<{
4232
+ onMoveShouldSetPanResponder?: ActiveCallback | undefined;
4233
+ onMoveShouldSetPanResponderCapture?: ActiveCallback | undefined;
4234
+ onStartShouldSetPanResponder?: ActiveCallback | undefined;
4235
+ onStartShouldSetPanResponderCapture?: ActiveCallback | undefined;
4236
+
4237
+ onPanResponderGrant?: (PassiveCallback | ActiveCallback) | undefined;
4238
+ onPanResponderReject?: PassiveCallback | undefined;
4239
+ onPanResponderStart?: PassiveCallback | undefined;
4240
+ onPanResponderEnd?: PassiveCallback | undefined;
4241
+ onPanResponderRelease?: PassiveCallback | undefined;
4242
+ onPanResponderMove?: PassiveCallback | undefined;
4243
+ onPanResponderTerminate?: PassiveCallback | undefined;
4244
+ onPanResponderTerminationRequest?: ActiveCallback | undefined;
4245
+ onShouldBlockNativeResponder?: ActiveCallback | undefined;
4246
+ }>;
4247
+
4248
+ export declare type PanResponderGestureState = {
4249
  stateID: number;
4250
+
4251
  moveX: number;
4252
+
4253
  moveY: number;
4254
+
4255
  x0: number;
4256
+
4257
  y0: number;
4258
+
4259
  dx: number;
4260
+
4261
  dy: number;
4262
+
4263
  vx: number;
4264
+
4265
  vy: number;
4266
+
4267
  numberActiveTouches: number;
4268
+ };
4269
+
4270
+ export declare type PanResponderInstance = ReturnType<
4271
+ (typeof PanResponder_2)['create']
4272
+ >;
4273
+
4274
+ declare const parallel: (
4275
+ animations: Array<CompositeAnimation>,
4276
+ config?: null | undefined | ParallelConfig
4277
+ ) => CompositeAnimation;
4278
+
4279
+ declare const parallel_2: typeof AnimatedImplementation_MODULE_EXPORT.parallel;
4280
+
4281
+ declare type parallel_2 = typeof parallel_2;
4282
+
4283
+ declare type ParallelConfig = {
4284
+ stopTogether?: boolean;
4285
+ };
4286
+
4287
+ declare type PassiveCallback = (
4288
+ event: GestureResponderEvent,
4289
+ gestureState: PanResponderGestureState
4290
+ ) => unknown;
4291
+
4292
+ declare type PassThroughProps = Readonly<{
4293
+ passthroughAnimatedPropExplicitValues?: React.JSX.LibraryManagedAttributes<
4294
+ typeof View,
4295
+ React.ComponentProps<typeof View>
4296
+ > | null;
4297
+ }>;
4298
+
4299
+ declare type PasswordRules = string;
4300
+
4301
+ declare type PasswordRules_2 = string;
4302
+
4303
+ export declare type Permission = PermissionsType[keyof PermissionsType];
4304
+
4305
+ export declare const PermissionsAndroid: typeof PermissionsAndroidInstance;
4306
+
4307
+ export declare type PermissionsAndroid = typeof PermissionsAndroid;
4308
+
4309
+ declare class PermissionsAndroid_2 {
4310
+ PERMISSIONS: PermissionsType;
4311
+ RESULTS: Readonly<{
4312
+ DENIED: 'denied';
4313
+ GRANTED: 'granted';
4314
+ NEVER_ASK_AGAIN: 'never_ask_again';
4315
+ }>;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4316
  checkPermission(permission: Permission): Promise<boolean>;
4317
  check(permission: Permission): Promise<boolean>;
4318
  requestPermission(
4319
  permission: Permission,
 
4321
  ): Promise<boolean>;
4322
  request(
4323
  permission: Permission,
4324
  rationale?: Rationale
4325
+ ): Promise<PermissionStatus_2>;
4326
  requestMultiple(
4327
  permissions: Array<Permission>
4328
+ ): Promise<{[permission in Permission]: PermissionStatus_2}>;
4329
  }
4330
+
4331
+ declare const PermissionsAndroidInstance: PermissionsAndroid_2;
4332
+
4333
+ declare type PermissionStatus_2 = 'granted' | 'denied' | 'never_ask_again';
4334
+ export {PermissionStatus_2 as PermissionStatus};
4335
+
4336
+ declare type PermissionsType = Readonly<{
4337
+ READ_CALENDAR: 'android.permission.READ_CALENDAR';
4338
+ WRITE_CALENDAR: 'android.permission.WRITE_CALENDAR';
4339
+ CAMERA: 'android.permission.CAMERA';
4340
+ READ_CONTACTS: 'android.permission.READ_CONTACTS';
4341
+ WRITE_CONTACTS: 'android.permission.WRITE_CONTACTS';
4342
+ GET_ACCOUNTS: 'android.permission.GET_ACCOUNTS';
4343
+ ACCESS_FINE_LOCATION: 'android.permission.ACCESS_FINE_LOCATION';
4344
+ ACCESS_COARSE_LOCATION: 'android.permission.ACCESS_COARSE_LOCATION';
4345
+ ACCESS_BACKGROUND_LOCATION: 'android.permission.ACCESS_BACKGROUND_LOCATION';
4346
+ RECORD_AUDIO: 'android.permission.RECORD_AUDIO';
4347
+ READ_PHONE_STATE: 'android.permission.READ_PHONE_STATE';
4348
+ CALL_PHONE: 'android.permission.CALL_PHONE';
4349
+ READ_CALL_LOG: 'android.permission.READ_CALL_LOG';
4350
+ WRITE_CALL_LOG: 'android.permission.WRITE_CALL_LOG';
4351
+ ADD_VOICEMAIL: 'com.android.voicemail.permission.ADD_VOICEMAIL';
4352
+ READ_VOICEMAIL: 'com.android.voicemail.permission.READ_VOICEMAIL';
4353
+ WRITE_VOICEMAIL: 'com.android.voicemail.permission.WRITE_VOICEMAIL';
4354
+ USE_SIP: 'android.permission.USE_SIP';
4355
+ PROCESS_OUTGOING_CALLS: 'android.permission.PROCESS_OUTGOING_CALLS';
4356
+ BODY_SENSORS: 'android.permission.BODY_SENSORS';
4357
+ BODY_SENSORS_BACKGROUND: 'android.permission.BODY_SENSORS_BACKGROUND';
4358
+ SEND_SMS: 'android.permission.SEND_SMS';
4359
+ RECEIVE_SMS: 'android.permission.RECEIVE_SMS';
4360
+ READ_SMS: 'android.permission.READ_SMS';
4361
+ RECEIVE_WAP_PUSH: 'android.permission.RECEIVE_WAP_PUSH';
4362
+ RECEIVE_MMS: 'android.permission.RECEIVE_MMS';
4363
+ READ_EXTERNAL_STORAGE: 'android.permission.READ_EXTERNAL_STORAGE';
4364
+ READ_MEDIA_IMAGES: 'android.permission.READ_MEDIA_IMAGES';
4365
+ READ_MEDIA_VIDEO: 'android.permission.READ_MEDIA_VIDEO';
4366
+ READ_MEDIA_AUDIO: 'android.permission.READ_MEDIA_AUDIO';
4367
+ READ_MEDIA_VISUAL_USER_SELECTED: 'android.permission.READ_MEDIA_VISUAL_USER_SELECTED';
4368
+ WRITE_EXTERNAL_STORAGE: 'android.permission.WRITE_EXTERNAL_STORAGE';
4369
+ BLUETOOTH_CONNECT: 'android.permission.BLUETOOTH_CONNECT';
4370
+ BLUETOOTH_SCAN: 'android.permission.BLUETOOTH_SCAN';
4371
+ BLUETOOTH_ADVERTISE: 'android.permission.BLUETOOTH_ADVERTISE';
4372
+ ACCESS_MEDIA_LOCATION: 'android.permission.ACCESS_MEDIA_LOCATION';
4373
+ ACCEPT_HANDOVER: 'android.permission.ACCEPT_HANDOVER';
4374
+ ACTIVITY_RECOGNITION: 'android.permission.ACTIVITY_RECOGNITION';
4375
+ ANSWER_PHONE_CALLS: 'android.permission.ANSWER_PHONE_CALLS';
4376
+ READ_PHONE_NUMBERS: 'android.permission.READ_PHONE_NUMBERS';
4377
+ UWB_RANGING: 'android.permission.UWB_RANGING';
4378
+ POST_NOTIFICATIONS: 'android.permission.POST_NOTIFICATIONS';
4379
+ NEARBY_WIFI_DEVICES: 'android.permission.NEARBY_WIFI_DEVICES';
4380
+ }>;
4381
+
4382
+ export declare class PixelRatio {
4383
+ static get(): number;
4384
+ static getFontScale(): number;
4385
+ static getPixelSizeForLayoutSize(layoutSize: number): number;
4386
+ static roundToNearestPixel(layoutSize: number): number;
4387
+ static startDetecting(): void;
4388
  }
4389
+
 
 
 
 
 
 
 
 
 
 
 
 
 
4390
+ export declare const Platform: Platform_2;
4391
+
4392
+ export declare type Platform = typeof Platform;
4393
+
4394
+ declare type Platform_2 =
4395
+ | IOSPlatform
4396
+ | AndroidPlatform
 
4397
+ | WindowsPlatform
4398
+ | MacOSPlatform
4399
+ | WebPlatform;
4400
+
 
 
 
 
 
 
 
4401
+ export declare function PlatformColor(...names: Array<string>): ColorValue;
4402
+
4403
+ declare type PlatformConfig = {};
4404
+
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4405
  export declare type PlatformOSType =
4406
  | 'ios'
4407
  | 'android'
4408
  | 'macos'
4409
  | 'windows'
4410
  | 'web'
4411
  | 'native';
4412
+
4413
+ export declare type PlatformSelectSpec<T> =
4414
+ | (Omit<
 
 
4415
+ OptionalPlatformSelectSpec<T>,
 
4416
+ keyof {
 
 
4417
+ default: T;
 
4418
+ }
 
4419
+ > & {
 
 
 
4420
+ default: T;
 
 
4421
+ })
4422
+ | OptionalPlatformSelectSpec<T>;
4423
+
4424
  declare type PointerEvent_2 = NativeSyntheticEvent<NativePointerEvent>;
4425
+
4426
+ declare type PointerEventProps = Readonly<{
4427
+ onClick?: ((event: PointerEvent_2) => void) | undefined;
4428
+ onClickCapture?: ((event: PointerEvent_2) => void) | undefined;
4429
  onPointerEnter?: ((event: PointerEvent_2) => void) | undefined;
4430
  onPointerEnterCapture?: ((event: PointerEvent_2) => void) | undefined;
4431
  onPointerLeave?: ((event: PointerEvent_2) => void) | undefined;
4432
  onPointerLeaveCapture?: ((event: PointerEvent_2) => void) | undefined;
4433
  onPointerMove?: ((event: PointerEvent_2) => void) | undefined;
4434
  onPointerMoveCapture?: ((event: PointerEvent_2) => void) | undefined;
4435
+ onPointerCancel?: ((e: PointerEvent_2) => void) | undefined;
4436
+ onPointerCancelCapture?: ((e: PointerEvent_2) => void) | undefined;
4437
+ onPointerDown?: ((e: PointerEvent_2) => void) | undefined;
4438
+ onPointerDownCapture?: ((e: PointerEvent_2) => void) | undefined;
4439
+ onPointerUp?: ((e: PointerEvent_2) => void) | undefined;
4440
+ onPointerUpCapture?: ((e: PointerEvent_2) => void) | undefined;
4441
+ onPointerOver?: ((e: PointerEvent_2) => void) | undefined;
4442
+ onPointerOverCapture?: ((e: PointerEvent_2) => void) | undefined;
4443
+ onPointerOut?: ((e: PointerEvent_2) => void) | undefined;
4444
+ onPointerOutCapture?: ((e: PointerEvent_2) => void) | undefined;
4445
+ onGotPointerCapture?: ((e: PointerEvent_2) => void) | undefined;
4446
+ onGotPointerCaptureCapture?: ((e: PointerEvent_2) => void) | undefined;
4447
+ onLostPointerCapture?: ((e: PointerEvent_2) => void) | undefined;
4448
+ onLostPointerCaptureCapture?: ((e: PointerEvent_2) => void) | undefined;
4449
+ }>;
4450
+
4451
+ declare type PointerEventProps_2 = Readonly<{
4452
+ onPointerEnter?: (event: PointerEvent_2) => void;
4453
+ onPointerLeave?: (event: PointerEvent_2) => void;
4454
+ onPointerMove?: (event: PointerEvent_2) => void;
4455
+ }>;
4456
+
4457
+ declare type PointProp = Readonly<{
4458
  x: number;
4459
  y: number;
4460
+ }>;
4461
+
4462
+ export declare type PointValue = {
4463
+ x: number;
4464
+ y: number;
4465
+ };
4466
+
4467
+ declare type PresentLocalNotificationDetails = {
4468
  alertBody: string;
4469
+ alertAction?: string;
4470
+ alertTitle?: string;
4471
+ soundName?: string;
4472
+ category?: string;
4473
+ userInfo?: Object;
4474
+ applicationIconBadgeNumber?: number;
4475
+ fireDate?: number;
4476
+ isSilent?: boolean;
4477
  };
4478
+
4479
+ declare const Presets: {
4480
+ easeInEaseOut: LayoutAnimationConfig;
4481
+ linear: LayoutAnimationConfig;
4482
+ spring: LayoutAnimationConfig;
4483
+ };
4484
+
4485
+ declare class Pressability {
4486
+ constructor(config: PressabilityConfig);
 
 
 
4487
+ configure(config: PressabilityConfig): void;
4488
+ reset(): void;
4489
+ getEventHandlers(): EventHandlers;
4490
+ static setLongPressDeactivationDistance(distance: number): void;
4491
  }
4492
+
4493
+ declare type PressabilityConfig = Readonly<{
4494
+ cancelable?: boolean | undefined;
4495
+
4496
+ disabled?: boolean | undefined;
4497
+
4498
+ hitSlop?: RectOrSize | undefined;
4499
+
4500
+ pressRectOffset?: RectOrSize | undefined;
4501
+
4502
+ android_disableSound?: boolean | undefined;
4503
+
4504
+ delayHoverIn?: number | undefined;
4505
+
4506
+ delayHoverOut?: number | undefined;
4507
+
4508
+ delayLongPress?: number | undefined;
4509
+
4510
+ delayPressIn?: number | undefined;
4511
+
4512
+ delayPressOut?: number | undefined;
4513
+
4514
+ minPressDuration?: number | undefined;
4515
+
4516
+ onBlur?: ((event: BlurEvent) => unknown) | undefined;
4517
+
4518
+ onFocus?: ((event: FocusEvent_2) => unknown) | undefined;
4519
+
4520
+ onHoverIn?: ((event: MouseEvent_2) => unknown) | undefined;
4521
+
4522
+ onHoverOut?: ((event: MouseEvent_2) => unknown) | undefined;
4523
+
 
 
4524
+ onLongPress?: ((event: GestureResponderEvent) => unknown) | undefined;
4525
+
 
4526
+ onPress?: ((event: GestureResponderEvent) => unknown) | undefined;
4527
+
4528
+ onPressIn?: ((event: GestureResponderEvent) => unknown) | undefined;
4529
+
4530
+ onPressMove?: ((event: GestureResponderEvent) => unknown) | undefined;
4531
+
4532
+ onPressOut?: ((event: GestureResponderEvent) => unknown) | undefined;
4533
+
4534
+ blockNativeResponder?: boolean | undefined;
4535
+ }>;
4536
+
4537
+ export declare const Pressable: (
4538
+ props: Omit<
4539
+ PressableProps,
4540
+ keyof {
 
4541
+ ref?: React.Ref<React.ComponentRef<typeof View>>;
4542
+ }
4543
+ > & {
4544
+ ref?: React.Ref<React.ComponentRef<typeof View>>;
4545
+ }
4546
+ ) => React.ReactNode;
4547
+
4548
+ export declare type Pressable = typeof Pressable;
4549
+
4550
+ declare type PressableAndroidRippleConfig = {
4551
+ color?: ColorValue;
4552
+ borderless?: boolean;
4553
+ radius?: number;
4554
+ foreground?: boolean;
4555
+ };
4556
+
4557
+ declare type PressableBaseProps = Readonly<{
4558
+ cancelable?: boolean | undefined;
4559
+
4560
  children?:
4561
+ | React.ReactNode
4562
+ | ((state: PressableStateCallbackType) => React.ReactNode);
4563
+
 
4564
+ delayHoverIn?: number | undefined;
4565
+
4566
+ delayHoverOut?: number | undefined;
4567
+
4568
+ delayLongPress?: number | undefined;
4569
+
4570
+ disabled?: boolean | undefined;
4571
+
4572
+ hitSlop?: RectOrSize | undefined;
4573
+
4574
+ pressRetentionOffset?: RectOrSize | undefined;
4575
+
4576
+ onLayout?: ((event: LayoutChangeEvent) => unknown) | undefined;
4577
+
4578
+ onHoverIn?: ((event: MouseEvent_2) => unknown) | undefined;
4579
+
4580
+ onHoverOut?: ((event: MouseEvent_2) => unknown) | undefined;
4581
+
4582
+ onLongPress?: ((event: GestureResponderEvent) => unknown) | undefined;
4583
+
4584
+ onPress?: ((event: GestureResponderEvent) => unknown) | undefined;
4585
+
4586
+ onPressIn?: ((event: GestureResponderEvent) => unknown) | undefined;
4587
+
4588
+ onPressMove?: ((event: GestureResponderEvent) => unknown) | undefined;
4589
+
4590
+ onPressOut?: ((event: GestureResponderEvent) => unknown) | undefined;
4591
+
4592
  style?:
4593
+ | ViewStyleProp_2
4594
+ | ((state: PressableStateCallbackType) => ViewStyleProp_2);
4595
+
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4596
  testID?: string | undefined;
4597
+
4598
+ android_disableSound?: boolean | undefined;
4599
+
4600
+ android_ripple?: PressableAndroidRippleConfig | undefined;
4601
+
4602
+ testOnly_pressed?: boolean | undefined;
4603
+
4604
+ unstable_pressDelay?: number | undefined;
4605
+ }>;
4606
+
4607
+ export declare type PressableProps = Readonly<
4608
+ Omit<ViewProps, keyof (PressableBaseProps | {})> &
4609
+ Omit<PressableBaseProps, keyof {}> & {}
4610
+ >;
4611
+
4612
+ export declare type PressableStateCallbackType = Readonly<{
4613
+ pressed: boolean;
4614
+ }>;
4615
+
4616
+ declare type PressRetentionOffset = Readonly<{
4617
+ top: number;
4618
+ left: number;
4619
+ bottom: number;
4620
+ right: number;
4621
+ }>;
4622
+
4623
+ declare type Primitive = string | number | boolean | symbol | void;
4624
+
4625
+ export declare const processColor: typeof processColor_2;
4626
+
4627
+ export declare type processColor = typeof processColor;
4628
+
4629
+ declare function processColor_2(
4630
+ color?: null | undefined | (number | ColorValue)
4631
+ ): null | undefined | ProcessedColorValue;
4632
+
4633
+ export declare type ProcessedColorValue = number | NativeColorValue;
4634
+
4635
+ export declare const ProgressBarAndroid: (
4636
+ props: Omit<
4637
+ ProgressBarAndroidProps,
4638
+ keyof {
4639
+ ref?: React.Ref<
4640
+ React.ComponentRef<ProgressBarAndroidNativeComponentType>
4641
+ >;
4642
+ }
4643
+ > & {
4644
+ ref?: React.Ref<
4645
+ React.ComponentRef<ProgressBarAndroidNativeComponentType>
4646
+ >;
4647
+ }
4648
+ ) => React.ReactNode;
4649
+
4650
+ export declare type ProgressBarAndroid = typeof ProgressBarAndroid;
4651
+
4652
+ declare const ProgressBarAndroidNativeComponent_MODULE_EXPORT: typeof ProgressBarAndroidNativeComponent_MODULE_EXPORT_2;
4653
+
4654
+ declare type ProgressBarAndroidNativeComponent_MODULE_EXPORT =
4655
+ typeof ProgressBarAndroidNativeComponent_MODULE_EXPORT;
4656
+
4657
+ declare const ProgressBarAndroidNativeComponent_MODULE_EXPORT_2: HostComponent<NativeProps_2>;
4658
+
4659
+ declare type ProgressBarAndroidNativeComponent_MODULE_EXPORT_2 =
4660
+ typeof ProgressBarAndroidNativeComponent_MODULE_EXPORT_2;
4661
+
4662
+ declare type ProgressBarAndroidNativeComponentType =
4663
+ typeof ProgressBarAndroidNativeComponent_MODULE_EXPORT;
4664
+
4665
+ export declare type ProgressBarAndroidProps = Readonly<
4666
+ Omit<
4667
+ ViewProps,
4668
+ keyof (
4669
+ | ProgressBarAndroidStyleAttrProp
4670
+ | {
4671
+ animating?: boolean | undefined;
4672
+
4673
+ color?: ColorValue | undefined;
4674
+
4675
+ testID?: string | undefined;
4676
+ }
4677
+ )
4678
+ > &
4679
+ Omit<
4680
+ ProgressBarAndroidStyleAttrProp,
4681
+ keyof {
4682
+ animating?: boolean | undefined;
4683
+
4684
+ color?: ColorValue | undefined;
4685
+
4686
+ testID?: string | undefined;
4687
+ }
4688
+ > & {
4689
+ animating?: boolean | undefined;
4690
+
4691
+ color?: ColorValue | undefined;
4692
+
4693
+ testID?: string | undefined;
4694
+ }
4695
+ >;
4696
+
4697
+ declare type ProgressBarAndroidStyleAttrProp =
4698
+ | {
4699
+ styleAttr: 'Horizontal';
4700
+ indeterminate: false;
4701
+ progress: number;
4702
+ }
4703
+ | {
4704
+ styleAttr:
4705
+ | 'Horizontal'
4706
+ | 'Normal'
4707
+ | 'Small'
4708
+ | 'Large'
4709
+ | 'Inverse'
4710
+ | 'SmallInverse'
4711
+ | 'LargeInverse';
4712
+ indeterminate: true;
4713
+ };
4714
+
4715
  export declare type PromiseTask = {
4716
  name: string;
4717
+ gen: () => Promise<void>;
4718
  };
4719
+
4720
+ declare type Props = Readonly<
4721
+ Omit<
4722
+ ImageProps,
4723
+ keyof (
4724
+ | ViewProps
4725
+ | {
4726
+ style?: ImageStyleProp | DangerouslyImpreciseStyle;
4727
+ tintColor?: ColorValue;
4728
+ shouldNotifyLoadEvents?: boolean;
4729
+ src?:
4730
+ | (ResolvedAssetSource | undefined)
4731
+ | (
4732
+ | ReadonlyArray<
4733
+ | Readonly<{
4734
+ uri?: string | undefined;
4735
+ }>
4736
+ | undefined
4737
+ >
4738
+ | undefined
4739
+ );
4740
+ headers?:
4741
+ | {
4742
+ [$$Key$$: string]: string;
4743
+ }
4744
+ | undefined;
4745
+ defaultSource?: (ImageSource | undefined) | (string | undefined);
4746
+ loadingIndicatorSrc?: string | undefined;
4747
+ }
4748
+ )
4749
+ > &
4750
+ Omit<
4751
+ ViewProps,
4752
+ keyof {
4753
+ style?: ImageStyleProp | DangerouslyImpreciseStyle;
4754
+ tintColor?: ColorValue;
4755
+ shouldNotifyLoadEvents?: boolean;
4756
+ src?:
4757
+ | (ResolvedAssetSource | undefined)
4758
+ | (
4759
+ | ReadonlyArray<
4760
+ | Readonly<{
4761
+ uri?: string | undefined;
4762
+ }>
4763
+ | undefined
4764
+ >
4765
+ | undefined
4766
+ );
4767
+ headers?:
4768
+ | {
4769
+ [$$Key$$: string]: string;
4770
+ }
4771
+ | undefined;
4772
+ defaultSource?: (ImageSource | undefined) | (string | undefined);
4773
+ loadingIndicatorSrc?: string | undefined;
4774
+ }
4775
+ > & {
4776
+ style?: ImageStyleProp | DangerouslyImpreciseStyle;
4777
+ tintColor?: ColorValue;
4778
+ shouldNotifyLoadEvents?: boolean;
4779
+ src?:
4780
+ | (ResolvedAssetSource | undefined)
4781
+ | (
4782
+ | ReadonlyArray<
4783
+ | Readonly<{
4784
+ uri?: string | undefined;
4785
+ }>
4786
+ | undefined
4787
+ >
4788
+ | undefined
4789
+ );
4790
+ headers?:
4791
+ | {
4792
+ [$$Key$$: string]: string;
4793
+ }
4794
+ | undefined;
4795
+ defaultSource?: (ImageSource | undefined) | (string | undefined);
4796
+ loadingIndicatorSrc?: string | undefined;
4797
+ }
4798
+ >;
4799
+
4800
+ declare type Props_2 = React.JSX.LibraryManagedAttributes<
4801
+ typeof ScrollView,
4802
+ React.ComponentProps<typeof ScrollView>
4803
+ >;
4804
+
4805
+ declare type PublicModalInstance = HostInstance;
4806
+
4807
+ declare interface PublicScrollViewInstance
4808
+ extends HostInstance,
4809
+ ScrollViewImperativeMethods {}
4810
+
4811
+ declare interface PushNotification {
4812
+ getMessage(): (string | undefined) | (Object | undefined);
4813
+
4814
+ getSound(): string | undefined;
4815
+
4816
+ getCategory(): string | undefined;
4817
+
4818
+ getAlert(): (string | undefined) | (Object | undefined);
4819
+
4820
+ getContentAvailable(): ContentAvailable;
4821
+
4822
+ getBadgeCount(): number | undefined;
4823
+
4824
+ getData(): Object | undefined;
4825
+
4826
+ getThreadID(): string | undefined;
4827
+
4828
  finish(result: string): void;
4829
  }
4830
+
4831
+ export declare type PushNotificationEventName = keyof {
4832
+ notification: string;
4833
+
4834
+ localNotification: string;
4835
+
4836
+ register: string;
4837
+
4838
+ registrationError: string;
4839
+ };
4840
+
4841
+ export declare class PushNotificationIOS {
 
 
 
 
 
 
 
4842
+ static FetchResult: FetchResult;
 
4843
+ static presentLocalNotification(
4844
+ details: PresentLocalNotificationDetails
4845
  ): void;
 
4846
+ static scheduleLocalNotification(
4847
+ details: ScheduleLocalNotificationDetails
4848
  ): void;
4849
+ static cancelAllLocalNotifications(): void;
4850
+ static removeAllDeliveredNotifications(): void;
4851
+ static getDeliveredNotifications(
4852
+ callback: (notifications: Array<Object>) => void
4853
  ): void;
4854
+ static removeDeliveredNotifications(identifiers: Array<string>): void;
4855
+ static setApplicationIconBadgeNumber(number: number): void;
4856
+ static getApplicationIconBadgeNumber(callback: Function): void;
4857
+ static cancelLocalNotifications(userInfo: Object): void;
4858
+ static getScheduledLocalNotifications(callback: Function): void;
4859
+ static addEventListener(
 
 
 
 
4860
  type: PushNotificationEventName,
4861
+ handler: Function
 
 
 
4862
  ): void;
4863
+ static removeEventListener(type: PushNotificationEventName): void;
4864
+ static requestPermissions(
4865
  permissions?: PushNotificationPermissions
4866
+ ): Promise<{
4867
+ alert: boolean;
4868
+ badge: boolean;
4869
+ sound: boolean;
4870
+ }>;
4871
+ static abandonPermissions(): void;
4872
+ static checkPermissions(
4873
  callback: (permissions: PushNotificationPermissions) => void
4874
  ): void;
4875
+ static getInitialNotification(): Promise<null | undefined | PushNotification>;
4876
+ static getAuthorizationStatus(
4877
+ callback: (authorizationStatus: number) => void
4878
+ ): void;
4879
+ constructor(nativeNotif: Object);
4880
+ finish(fetchResult: string): void;
4881
+ getMessage(): (null | undefined | string) | (null | undefined | Object);
4882
+ getSound(): null | undefined | string;
4883
+ getCategory(): null | undefined | string;
4884
+ getAlert(): (null | undefined | string) | (null | undefined | Object);
4885
+ getContentAvailable(): ContentAvailable;
4886
+ getBadgeCount(): null | undefined | number;
4887
+ getData(): null | undefined | Object;
4888
+ getThreadID(): null | undefined | string;
4889
  }
4890
+
4891
+ export declare type PushNotificationPermissions = {
4892
+ alert: boolean;
4893
+ badge: boolean;
4894
+ sound: boolean;
4895
+ [key: string]: boolean | number;
 
 
4896
+ };
4897
+
4898
+ export declare type Rationale = {
4899
  title: string;
4900
  message: string;
4901
+ buttonPositive?: string;
4902
+ buttonNegative?: string;
4903
+ buttonNeutral?: string;
4904
+ };
4905
+
4906
+ declare type RCTDeviceEventDefinitions = {
4907
+ [name: string]: Array<any>;
4908
+ };
4909
+
4910
+ declare const RCTNativeAppEventEmitter: typeof DeviceEventEmitter;
4911
+
4912
+ declare const RCTNetworking: {
4913
+ addListener<K extends keyof RCTNetworkingEventDefinitions>(
4914
+ eventType: K,
4915
+ listener: (...$$REST$$: RCTNetworkingEventDefinitions[K]) => unknown,
4916
+ context?: unknown
4917
+ ): EventSubscription;
4918
+ sendRequest(
4919
+ method: string,
4920
+ trackingName: string | undefined,
4921
+ url: string,
4922
+ headers: {},
4923
+ data: RequestBody,
4924
+ responseType: NativeResponseType,
4925
+ incrementalUpdates: boolean,
4926
+ timeout: number,
4927
+ callback: (requestId: number) => void,
4928
+ withCredentials: boolean
4929
+ ): void;
4930
+ abortRequest(requestId: number): void;
4931
+ clearCookies(callback: (result: boolean) => void): void;
4932
+ };
4933
+
4934
+ declare type RCTNetworkingEventDefinitions = Readonly<{
4935
+ didSendNetworkData: [[number, number, number]];
4936
+ didReceiveNetworkResponse: [
4937
+ [
4938
+ number,
4939
+ number,
4940
+ (
4941
+ | {
4942
+ [$$Key$$: string]: string;
4943
+ }
4944
+ | undefined
4945
+ ),
4946
+ string | undefined,
4947
+ ],
4948
+ ];
4949
+ didReceiveNetworkData: [[number, string]];
4950
+ didReceiveNetworkIncrementalData: [[number, string, number, number]];
4951
+ didReceiveNetworkDataProgress: [[number, number, number]];
4952
+ didCompleteNetworkResponse: [[number, string, boolean]];
4953
+ }>;
4954
+
4955
+ declare type Rect = Readonly<{
4956
+ bottom?: number | undefined;
4957
+ left?: number | undefined;
4958
+ right?: number | undefined;
4959
+ top?: number | undefined;
4960
+ }>;
4961
+
4962
+ declare type RectOrSize = Rect | number;
4963
+
4964
+ export declare class RefreshControl extends React.Component<RefreshControlProps> {
4965
+ componentDidMount(): void;
4966
+ componentDidUpdate(prevProps: RefreshControlProps): void;
4967
+ render(): React.ReactNode;
4968
  }
4969
+
 
 
 
 
 
 
 
 
 
4970
+ declare type RefreshControlBaseProps = Readonly<{
 
 
 
 
 
4971
+ onRefresh?: (() => void | Promise<void>) | undefined;
4972
+
4973
  refreshing: boolean;
4974
+
4975
  progressViewOffset?: number | undefined;
4976
+ }>;
4977
+
4978
+ export declare type RefreshControlProps = Readonly<
4979
+ Omit<
4980
+ ViewProps,
4981
+ keyof (
4982
+ | RefreshControlPropsIOS
4983
+ | RefreshControlPropsAndroid
4984
+ | RefreshControlBaseProps
4985
+ | {}
4986
+ )
4987
+ > &
4988
+ Omit<
4989
+ RefreshControlPropsIOS,
4990
+ keyof (RefreshControlPropsAndroid | RefreshControlBaseProps | {})
4991
+ > &
4992
+ Omit<RefreshControlPropsAndroid, keyof (RefreshControlBaseProps | {})> &
4993
+ Omit<RefreshControlBaseProps, keyof {}> & {}
4994
+ >;
4995
+
4996
+ export declare type RefreshControlPropsAndroid = Readonly<{
 
4997
  enabled?: boolean | undefined;
4998
+
4999
+ colors?: ReadonlyArray<ColorValue> | undefined;
5000
+
5001
  progressBackgroundColor?: ColorValue | undefined;
5002
+
5003
+ size?: ('default' | 'large') | undefined;
5004
+ }>;
5005
+
5006
+ export declare type RefreshControlPropsIOS = Readonly<{
5007
  tintColor?: ColorValue | undefined;
5008
+
5009
  titleColor?: ColorValue | undefined;
5010
+
5011
+ title?: string | undefined;
5012
+ }>;
5013
+
5014
+ declare type RegisterCallableModule = (
5015
  name: string,
5016
+ moduleOrFactory: Module | (($$PARAM_0$$: void) => Module)
5017
  ) => void;
5018
+
5019
+ export declare const registerCallableModule: typeof registerCallableModule_2;
5020
+
5021
+ export declare type registerCallableModule = typeof registerCallableModule;
5022
+
5023
+ declare const registerCallableModule_2: RegisterCallableModule;
5024
+
5025
+ declare function registerCancellableHeadlessTask(
5026
+ taskKey: string,
5027
+ taskProvider: TaskProvider,
5028
+ taskCancelProvider: TaskCancelProvider
5029
+ ): void;
5030
+
5031
+ declare function registerComponent(
5032
+ appKey: string,
5033
+ componentProvider: ComponentProvider,
5034
+ section?: boolean
5035
+ ): string;
5036
+
5037
+ declare function registerConfig(config: Array<AppConfig>): void;
5038
+
5039
+ declare function registerHeadlessTask(
5040
+ taskKey: string,
5041
+ taskProvider: TaskProvider
5042
+ ): void;
5043
+
5044
+ declare function registerRunnable(appKey: string, run: Runnable): string;
5045
+
5046
+ declare function registerSection(
5047
+ appKey: string,
5048
+ component: ComponentProvider
5049
+ ): void;
5050
+
5051
+ export declare type Registry = {
5052
+ sections: ReadonlyArray<string>;
5053
+ runnables: Runnables;
5054
+ };
5055
+
5056
+ declare type RequestBody =
5057
+ | string
5058
+ | Blob_2
5059
+ | FormData_2
5060
+ | {
5061
+ uri: string;
5062
+ }
5063
+ | ArrayBuffer
5064
+ | ArrayBufferView;
5065
+
5066
+ declare type RequiredProps<ItemT> = {
5067
+ data: Readonly<ArrayLike<ItemT>> | undefined;
5068
+ };
5069
+
5070
+ declare type RequiredProps_2<ItemT, SectionT = DefaultSectionT> = {
5071
+ sections: ReadonlyArray<SectionData<ItemT, SectionT>>;
5072
+ };
5073
+
5074
+ export declare const requireNativeComponent: typeof requireNativeComponent_2;
5075
+
5076
+ export declare type requireNativeComponent = typeof requireNativeComponent;
5077
+
5078
+ declare const requireNativeComponent_2: <T extends {}>(
5079
+ uiViewClassName: string
5080
+ ) => HostComponent<T>;
5081
+
5082
+ declare type ResolvedAssetSource = {
5083
+ readonly width: number | undefined;
5084
+ readonly height: number | undefined;
5085
+ readonly uri: string;
5086
+ readonly scale: number;
5087
+ };
5088
+
5089
+ export declare type ResponderSyntheticEvent<T> = Readonly<
5090
+ Omit<
5091
+ NativeSyntheticEvent<T>,
5092
+ keyof {
5093
+ touchHistory: Readonly<{
5094
+ indexOfSingleActiveTouch: number;
5095
+ mostRecentTimeStamp: number;
5096
+ numberActiveTouches: number;
5097
+ touchBank: ReadonlyArray<
5098
+ Readonly<{
5099
+ touchActive: boolean;
5100
+ startPageX: number;
5101
+ startPageY: number;
5102
+ startTimeStamp: number;
5103
+ currentPageX: number;
5104
+ currentPageY: number;
5105
+ currentTimeStamp: number;
5106
+ previousPageX: number;
5107
+ previousPageY: number;
5108
+ previousTimeStamp: number;
5109
+ }>
5110
+ >;
5111
+ }>;
5112
+ }
5113
+ > & {
5114
+ touchHistory: Readonly<{
5115
+ indexOfSingleActiveTouch: number;
5116
+ mostRecentTimeStamp: number;
5117
+ numberActiveTouches: number;
5118
+ touchBank: ReadonlyArray<
5119
+ Readonly<{
5120
+ touchActive: boolean;
5121
+ startPageX: number;
5122
+ startPageY: number;
5123
+ startTimeStamp: number;
5124
+ currentPageX: number;
5125
+ currentPageY: number;
5126
+ currentTimeStamp: number;
5127
+ previousPageX: number;
5128
+ previousPageY: number;
5129
+ previousTimeStamp: number;
5130
+ }>
5131
+ >;
5132
+ }>;
5133
+ }
5134
+ >;
5135
+
5136
+ declare type ReturnKeyType = 'done' | 'go' | 'next' | 'search' | 'send';
5137
+
5138
+ declare type ReturnKeyType_2 = 'done' | 'go' | 'next' | 'search' | 'send';
5139
+
5140
+ declare type ReturnKeyTypeAndroid = 'none' | 'previous';
5141
+
5142
+ declare type ReturnKeyTypeAndroid_2 = 'none' | 'previous';
5143
+
5144
+ declare type ReturnKeyTypeIOS =
5145
  | 'default'
5146
+ | 'emergency-call'
5147
  | 'google'
5148
  | 'join'
5149
  | 'route'
5150
+ | 'yahoo';
5151
+
5152
+ declare type ReturnKeyTypeIOS_2 =
5153
+ | 'default'
5154
+ | 'emergency-call'
5155
+ | 'google'
5156
+ | 'join'
5157
+ | 'route'
5158
+ | 'yahoo';
5159
+
5160
  export declare type ReturnKeyTypeOptions =
5161
  | ReturnKeyType
5162
+ | ReturnKeyTypeIOS
5163
+ | ReturnKeyTypeAndroid;
5164
+
5165
+ declare type ReturnKeyTypeOptions_2 =
5166
+ | ReturnKeyType_2
5167
+ | ReturnKeyTypeIOS_2
 
 
5168
+ | ReturnKeyTypeAndroid_2;
5169
+
5170
+ declare type RgbaAnimatedValue = {
5171
+ readonly r: AnimatedValue;
5172
+ readonly g: AnimatedValue;
5173
+ readonly b: AnimatedValue;
5174
+ readonly a: AnimatedValue;
5175
+ };
5176
+
5177
+ declare type RgbaValue = {
5178
+ readonly r: number;
5179
+ readonly g: number;
5180
+ readonly b: number;
5181
+ readonly a: number;
5182
+ };
5183
+
5184
+ declare type Role =
5185
  | 'alert'
5186
  | 'alertdialog'
5187
  | 'application'
5188
  | 'article'
 
5246
  | 'tooltip'
5247
  | 'tree'
5248
  | 'treegrid'
5249
  | 'treeitem';
5250
+
5251
+ export declare type RootTag = symbol & {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5252
+ __RootTag__: string;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5253
  };
5254
+
5255
+ export declare const RootTagContext: React.Context<RootTag>;
5256
+
5257
+ export declare type RootTagContext = typeof RootTagContext;
5258
+
5259
+ export declare type RootViewStyleProvider = (
5260
+ appParameters: Object
5261
+ ) => ViewStyleProp;
5262
+
5263
+ declare function runApplication(
5264
+ appKey: string,
5265
+ appParameters: AppParameters,
5266
+ displayMode?: number
5267
+ ): void;
5268
+
5269
+ export declare type Runnable = (
5270
+ appParameters: AppParameters,
5271
+ displayMode: DisplayModeType
5272
+ ) => void;
5273
+
5274
+ export declare type Runnables = {
5275
+ [appKey: string]: Runnable;
5276
+ };
5277
+
5278
+ export declare const SafeAreaView: typeof exported;
5279
+
5280
+ export declare type SafeAreaView = typeof SafeAreaView;
5281
+
5282
+ export declare type ScaledSize = DisplayMetrics;
5283
+
5284
+ declare type ScheduleLocalNotificationDetails = Omit<
5285
+ PresentLocalNotificationDetails,
5286
+ keyof {
5287
+ repeatInterval?: 'year' | 'month' | 'week' | 'day' | 'hour' | 'minute';
5288
+ }
5289
+ > & {
5290
+ repeatInterval?: 'year' | 'month' | 'week' | 'day' | 'hour' | 'minute';
5291
+ };
5292
+
5293
+ export declare type ScrollEvent = NativeSyntheticEvent<NativeScrollEvent>;
5294
+
5295
+ declare type ScrollResponderType = ScrollViewImperativeMethods;
5296
+
5297
+ export {ScrollToLocationParamsType};
5298
+
5299
+ export declare const ScrollView: typeof Wrapper & ScrollViewComponentStatics;
5300
+
5301
+ export declare type ScrollView = typeof ScrollView;
5302
+
5303
+ declare class ScrollView_2 extends React.Component<ScrollViewProps, State_2> {
5304
+ static Context: typeof ScrollViewContext_MODULE_EXPORT;
5305
+ constructor(props: ScrollViewProps);
5306
+ state: State_2;
5307
+ componentDidMount(): void;
5308
+ componentDidUpdate(prevProps: ScrollViewProps): void;
5309
+ componentWillUnmount(): void;
5310
+ getScrollResponder: () => ScrollResponderType;
5311
+ getScrollableNode: () => null | undefined | number;
5312
+ getInnerViewNode: () => null | undefined | number;
5313
+ getInnerViewRef: () => InnerViewInstance | null;
5314
+ getNativeScrollRef: () => HostInstance | null;
5315
+ scrollTo: (
5316
+ options?: ScrollViewScrollToOptions | number,
5317
+ deprecatedX?: number,
5318
+ deprecatedAnimated?: boolean
5319
+ ) => void;
5320
+ scrollToEnd: (options?: null | undefined | ScrollViewScrollToOptions) => void;
5321
+ flashScrollIndicators: () => void;
5322
+ scrollResponderScrollNativeHandleToKeyboard: (
5323
+ nodeHandle: number | HostInstance,
5324
+ additionalOffset?: number,
5325
+ preventNegativeScrollOffset?: boolean
5326
+ ) => void;
5327
+ scrollResponderZoomTo: (
5328
  rect: {
5329
  x: number;
5330
  y: number;
5331
  width: number;
5332
  height: number;
5333
+ animated?: boolean;
5334
  },
5335
+ animated?: boolean
5336
+ ) => void;
 
 
 
 
 
 
 
 
 
 
 
 
 
5337
+ scrollResponderKeyboardWillShow: (e: KeyboardEvent_2) => void;
5338
+ scrollResponderKeyboardWillHide: (e: KeyboardEvent_2) => void;
5339
+ scrollResponderKeyboardDidShow: (e: KeyboardEvent_2) => void;
5340
+ scrollResponderKeyboardDidHide: (e: KeyboardEvent_2) => void;
5341
+ render(): React.ReactNode;
5342
  }
5343
+
5344
+ declare type ScrollViewComponentStatics = Readonly<{
5345
+ Context: typeof ScrollViewContext_MODULE_EXPORT;
5346
+ }>;
5347
+
5348
+ declare const ScrollViewContext: React.Context<Value>;
5349
+
5350
+ declare const ScrollViewContext_MODULE_EXPORT: typeof ScrollViewContext;
5351
+
5352
+ declare type ScrollViewContext_MODULE_EXPORT =
5353
+ typeof ScrollViewContext_MODULE_EXPORT;
5354
+
5355
+ declare interface ScrollViewImperativeMethods {
5356
+ readonly getScrollResponder: ScrollView_2['getScrollResponder'];
5357
+ readonly getScrollableNode: ScrollView_2['getScrollableNode'];
5358
+ readonly getInnerViewNode: ScrollView_2['getInnerViewNode'];
5359
+ readonly getInnerViewRef: ScrollView_2['getInnerViewRef'];
5360
+ readonly getNativeScrollRef: ScrollView_2['getNativeScrollRef'];
5361
+ readonly scrollTo: ScrollView_2['scrollTo'];
 
 
 
 
 
 
 
 
 
 
 
5362
+ readonly scrollToEnd: ScrollView_2['scrollToEnd'];
5363
+ readonly flashScrollIndicators: ScrollView_2['flashScrollIndicators'];
5364
+ readonly scrollResponderZoomTo: ScrollView_2['scrollResponderZoomTo'];
 
 
5365
+ readonly scrollResponderScrollNativeHandleToKeyboard: ScrollView_2['scrollResponderScrollNativeHandleToKeyboard'];
 
5366
  }
5367
+
5368
+ declare type ScrollViewNativeComponent =
5369
+ typeof ScrollViewNativeComponent_MODULE_EXPORT;
5370
+
5371
+ declare const ScrollViewNativeComponent_2: HostComponent<ScrollViewNativeProps>;
5372
+
5373
+ declare const ScrollViewNativeComponent_MODULE_EXPORT: typeof ScrollViewNativeComponent_2;
5374
+
5375
+ declare type ScrollViewNativeComponent_MODULE_EXPORT =
5376
+ typeof ScrollViewNativeComponent_MODULE_EXPORT;
5377
+
5378
+ declare type ScrollViewNativeProps = Readonly<
5379
+ Omit<
5380
+ ViewProps,
5381
+ keyof {
5382
+ alwaysBounceHorizontal?: boolean | undefined;
5383
+ alwaysBounceVertical?: boolean | undefined;
5384
+ automaticallyAdjustContentInsets?: boolean | undefined;
5385
+ automaticallyAdjustKeyboardInsets?: boolean | undefined;
5386
+ automaticallyAdjustsScrollIndicatorInsets?: boolean | undefined;
5387
+ bounces?: boolean | undefined;
5388
+ bouncesZoom?: boolean | undefined;
5389
+ canCancelContentTouches?: boolean | undefined;
5390
+ centerContent?: boolean | undefined;
5391
+ contentInset?: EdgeInsetsProp | undefined;
5392
+ contentInsetAdjustmentBehavior?:
5393
+ | ('automatic' | 'scrollableAxes' | 'never' | 'always')
5394
+ | undefined;
5395
+ contentOffset?: PointProp | undefined;
5396
+ decelerationRate?: ('fast' | 'normal' | number) | undefined;
5397
+ directionalLockEnabled?: boolean | undefined;
5398
+ disableIntervalMomentum?: boolean | undefined;
5399
+ endFillColor?: ColorValue | undefined;
5400
+ fadingEdgeLength?: number | undefined;
5401
+ indicatorStyle?: ('default' | 'black' | 'white') | undefined;
5402
+ isInvertedVirtualizedList?: boolean | undefined;
5403
+ keyboardDismissMode?: ('none' | 'on-drag' | 'interactive') | undefined;
5404
+ maintainVisibleContentPosition?:
5405
+ | Readonly<{
5406
+ minIndexForVisible: number;
5407
+ autoscrollToTopThreshold?: number | undefined;
5408
+ }>
5409
+ | undefined;
5410
+ maximumZoomScale?: number | undefined;
5411
+ minimumZoomScale?: number | undefined;
5412
+ nestedScrollEnabled?: boolean | undefined;
5413
+ onMomentumScrollBegin?: ((event: ScrollEvent) => void) | undefined;
5414
+ onMomentumScrollEnd?: ((event: ScrollEvent) => void) | undefined;
5415
+ onScroll?: ((event: ScrollEvent) => void) | undefined;
5416
+ onScrollBeginDrag?: ((event: ScrollEvent) => void) | undefined;
5417
+ onScrollEndDrag?: ((event: ScrollEvent) => void) | undefined;
5418
+ onScrollToTop?: (event: ScrollEvent) => void;
5419
+ overScrollMode?: ('auto' | 'always' | 'never') | undefined;
5420
+ pagingEnabled?: boolean | undefined;
5421
+ persistentScrollbar?: boolean | undefined;
5422
+ pinchGestureEnabled?: boolean | undefined;
5423
+ scrollEnabled?: boolean | undefined;
5424
+ scrollEventThrottle?: number | undefined;
5425
+ scrollIndicatorInsets?: EdgeInsetsProp | undefined;
5426
+ scrollPerfTag?: string | undefined;
5427
+ scrollToOverflowEnabled?: boolean | undefined;
5428
+ scrollsToTop?: boolean | undefined;
5429
+ sendMomentumEvents?: boolean | undefined;
5430
+ showsHorizontalScrollIndicator?: boolean | undefined;
5431
+ showsVerticalScrollIndicator?: boolean | undefined;
5432
+ snapToAlignment?: ('start' | 'center' | 'end') | undefined;
5433
+ snapToEnd?: boolean | undefined;
5434
+ snapToInterval?: number | undefined;
5435
+ snapToOffsets?: ReadonlyArray<number> | undefined;
5436
+ snapToStart?: boolean | undefined;
5437
+ zoomScale?: number | undefined;
5438
+ onResponderGrant?:
5439
+ | ((e: GestureResponderEvent) => void | boolean)
5440
+ | undefined;
5441
+ }
5442
+ > & {
5443
+ alwaysBounceHorizontal?: boolean | undefined;
5444
+ alwaysBounceVertical?: boolean | undefined;
5445
+ automaticallyAdjustContentInsets?: boolean | undefined;
5446
+ automaticallyAdjustKeyboardInsets?: boolean | undefined;
5447
+ automaticallyAdjustsScrollIndicatorInsets?: boolean | undefined;
5448
+ bounces?: boolean | undefined;
5449
+ bouncesZoom?: boolean | undefined;
5450
+ canCancelContentTouches?: boolean | undefined;
5451
+ centerContent?: boolean | undefined;
5452
+ contentInset?: EdgeInsetsProp | undefined;
5453
+ contentInsetAdjustmentBehavior?:
5454
+ | ('automatic' | 'scrollableAxes' | 'never' | 'always')
5455
+ | undefined;
5456
+ contentOffset?: PointProp | undefined;
5457
+ decelerationRate?: ('fast' | 'normal' | number) | undefined;
5458
+ directionalLockEnabled?: boolean | undefined;
5459
+ disableIntervalMomentum?: boolean | undefined;
5460
+ endFillColor?: ColorValue | undefined;
5461
+ fadingEdgeLength?: number | undefined;
5462
+ indicatorStyle?: ('default' | 'black' | 'white') | undefined;
5463
+ isInvertedVirtualizedList?: boolean | undefined;
5464
+ keyboardDismissMode?: ('none' | 'on-drag' | 'interactive') | undefined;
5465
+ maintainVisibleContentPosition?:
5466
+ | Readonly<{
5467
+ minIndexForVisible: number;
5468
+ autoscrollToTopThreshold?: number | undefined;
5469
+ }>
5470
+ | undefined;
5471
+ maximumZoomScale?: number | undefined;
5472
+ minimumZoomScale?: number | undefined;
5473
+ nestedScrollEnabled?: boolean | undefined;
5474
+ onMomentumScrollBegin?: ((event: ScrollEvent) => void) | undefined;
5475
+ onMomentumScrollEnd?: ((event: ScrollEvent) => void) | undefined;
5476
+ onScroll?: ((event: ScrollEvent) => void) | undefined;
5477
+ onScrollBeginDrag?: ((event: ScrollEvent) => void) | undefined;
5478
+ onScrollEndDrag?: ((event: ScrollEvent) => void) | undefined;
5479
+ onScrollToTop?: (event: ScrollEvent) => void;
5480
+ overScrollMode?: ('auto' | 'always' | 'never') | undefined;
5481
+ pagingEnabled?: boolean | undefined;
5482
+ persistentScrollbar?: boolean | undefined;
5483
+ pinchGestureEnabled?: boolean | undefined;
5484
+ scrollEnabled?: boolean | undefined;
5485
+ scrollEventThrottle?: number | undefined;
5486
+ scrollIndicatorInsets?: EdgeInsetsProp | undefined;
5487
+ scrollPerfTag?: string | undefined;
5488
+ scrollToOverflowEnabled?: boolean | undefined;
5489
+ scrollsToTop?: boolean | undefined;
5490
+ sendMomentumEvents?: boolean | undefined;
5491
+ showsHorizontalScrollIndicator?: boolean | undefined;
5492
+ showsVerticalScrollIndicator?: boolean | undefined;
5493
+ snapToAlignment?: ('start' | 'center' | 'end') | undefined;
5494
+ snapToEnd?: boolean | undefined;
5495
+ snapToInterval?: number | undefined;
5496
+ snapToOffsets?: ReadonlyArray<number> | undefined;
5497
+ snapToStart?: boolean | undefined;
5498
+ zoomScale?: number | undefined;
5499
+ onResponderGrant?:
5500
+ | ((e: GestureResponderEvent) => void | boolean)
5501
+ | undefined;
5502
+ }
5503
+ >;
5504
+
5505
+ export declare type ScrollViewProps = Readonly<
5506
+ Omit<
5507
+ ViewProps,
5508
+ keyof (
5509
+ | ScrollViewPropsIOS
5510
+ | ScrollViewPropsAndroid
5511
+ | {
5512
+ contentContainerStyle?: ViewStyleProp | undefined;
5513
+
5514
+ contentOffset?: PointProp | undefined;
5515
+
5516
+ disableIntervalMomentum?: boolean | undefined;
5517
+
5518
+ decelerationRate?: DecelerationRateType | undefined;
5519
+
5520
+ experimental_endDraggingSensitivityMultiplier?: number | undefined;
5521
+
5522
+ horizontal?: boolean | undefined;
5523
+
5524
+ invertStickyHeaders?: boolean | undefined;
5525
+
5526
+ keyboardDismissMode?:
5527
+ | ('none' | 'on-drag' | 'interactive')
5528
+ | undefined;
5529
+
5530
+ keyboardShouldPersistTaps?:
5531
+ | ('always' | 'never' | 'handled' | true | false)
5532
+ | undefined;
5533
+
5534
+ maintainVisibleContentPosition?:
5535
+ | Readonly<{
5536
+ minIndexForVisible: number;
5537
+ autoscrollToTopThreshold?: number | undefined;
5538
+ }>
5539
+ | undefined;
5540
+
5541
+ onMomentumScrollBegin?: ((event: ScrollEvent) => void) | undefined;
5542
+
5543
+ onMomentumScrollEnd?: ((event: ScrollEvent) => void) | undefined;
5544
+
5545
+ onScroll?: ((event: ScrollEvent) => void) | undefined;
5546
+
5547
+ onScrollBeginDrag?: ((event: ScrollEvent) => void) | undefined;
5548
+
5549
+ onScrollEndDrag?: ((event: ScrollEvent) => void) | undefined;
5550
+
5551
+ onContentSizeChange?: (
5552
+ contentWidth: number,
5553
+ contentHeight: number
5554
+ ) => void;
5555
+ onKeyboardDidShow?: (event: KeyboardEvent_2) => void;
5556
+ onKeyboardDidHide?: (event: KeyboardEvent_2) => void;
5557
+ onKeyboardWillShow?: (event: KeyboardEvent_2) => void;
5558
+ onKeyboardWillHide?: (event: KeyboardEvent_2) => void;
5559
+
5560
+ pagingEnabled?: boolean | undefined;
5561
+
5562
+ scrollEnabled?: boolean | undefined;
5563
+
5564
+ scrollEventThrottle?: number | undefined;
5565
+
5566
+ showsVerticalScrollIndicator?: boolean | undefined;
5567
+
5568
+ stickyHeaderHiddenOnScroll?: boolean | undefined;
5569
+
5570
+ stickyHeaderIndices?: ReadonlyArray<number> | undefined;
5571
+
5572
+ StickyHeaderComponent?: StickyHeaderComponentType;
5573
+
5574
+ snapToAlignment?: ('start' | 'center' | 'end') | undefined;
5575
+
5576
+ snapToInterval?: number | undefined;
5577
+
5578
+ snapToOffsets?: ReadonlyArray<number> | undefined;
5579
+
5580
+ snapToStart?: boolean | undefined;
5581
+
5582
+ snapToEnd?: boolean | undefined;
5583
+
5584
+ removeClippedSubviews?: boolean | undefined;
5585
+
5586
+ refreshControl?: React.ReactNode | undefined;
5587
+ children?: React.ReactNode;
5588
+
5589
+ innerViewRef?: React.Ref<InnerViewInstance>;
5590
+
5591
+ scrollViewRef?: React.Ref<PublicScrollViewInstance>;
5592
+ }
5593
+ )
5594
+ > &
5595
+ Omit<
5596
+ ScrollViewPropsIOS,
5597
+ keyof (
5598
+ | ScrollViewPropsAndroid
5599
+ | {
5600
+ contentContainerStyle?: ViewStyleProp | undefined;
5601
+
5602
+ contentOffset?: PointProp | undefined;
5603
+
5604
+ disableIntervalMomentum?: boolean | undefined;
5605
+
5606
+ decelerationRate?: DecelerationRateType | undefined;
5607
+
5608
+ experimental_endDraggingSensitivityMultiplier?: number | undefined;
5609
+
5610
+ horizontal?: boolean | undefined;
5611
+
5612
+ invertStickyHeaders?: boolean | undefined;
5613
+
5614
+ keyboardDismissMode?:
5615
+ | ('none' | 'on-drag' | 'interactive')
5616
+ | undefined;
5617
+
5618
+ keyboardShouldPersistTaps?:
5619
+ | ('always' | 'never' | 'handled' | true | false)
5620
+ | undefined;
5621
+
5622
+ maintainVisibleContentPosition?:
5623
+ | Readonly<{
5624
+ minIndexForVisible: number;
5625
+ autoscrollToTopThreshold?: number | undefined;
5626
+ }>
5627
+ | undefined;
5628
+
5629
+ onMomentumScrollBegin?: ((event: ScrollEvent) => void) | undefined;
5630
+
5631
+ onMomentumScrollEnd?: ((event: ScrollEvent) => void) | undefined;
5632
+
5633
+ onScroll?: ((event: ScrollEvent) => void) | undefined;
5634
+
5635
+ onScrollBeginDrag?: ((event: ScrollEvent) => void) | undefined;
5636
+
5637
+ onScrollEndDrag?: ((event: ScrollEvent) => void) | undefined;
5638
+
5639
+ onContentSizeChange?: (
5640
+ contentWidth: number,
5641
+ contentHeight: number
5642
+ ) => void;
5643
+ onKeyboardDidShow?: (event: KeyboardEvent_2) => void;
5644
+ onKeyboardDidHide?: (event: KeyboardEvent_2) => void;
5645
+ onKeyboardWillShow?: (event: KeyboardEvent_2) => void;
5646
+ onKeyboardWillHide?: (event: KeyboardEvent_2) => void;
5647
+
5648
+ pagingEnabled?: boolean | undefined;
5649
+
5650
+ scrollEnabled?: boolean | undefined;
5651
+
5652
+ scrollEventThrottle?: number | undefined;
5653
+
5654
+ showsVerticalScrollIndicator?: boolean | undefined;
5655
+
5656
+ stickyHeaderHiddenOnScroll?: boolean | undefined;
5657
+
5658
+ stickyHeaderIndices?: ReadonlyArray<number> | undefined;
5659
+
5660
+ StickyHeaderComponent?: StickyHeaderComponentType;
5661
+
5662
+ snapToAlignment?: ('start' | 'center' | 'end') | undefined;
5663
+
5664
+ snapToInterval?: number | undefined;
5665
+
5666
+ snapToOffsets?: ReadonlyArray<number> | undefined;
5667
+
5668
+ snapToStart?: boolean | undefined;
5669
+
5670
+ snapToEnd?: boolean | undefined;
5671
+
5672
+ removeClippedSubviews?: boolean | undefined;
5673
+
5674
+ refreshControl?: React.ReactNode | undefined;
5675
+ children?: React.ReactNode;
5676
+
5677
+ innerViewRef?: React.Ref<InnerViewInstance>;
5678
+
5679
+ scrollViewRef?: React.Ref<PublicScrollViewInstance>;
5680
+ }
5681
+ )
5682
+ > &
5683
+ Omit<
5684
+ ScrollViewPropsAndroid,
5685
+ keyof {
5686
+ contentContainerStyle?: ViewStyleProp | undefined;
5687
+
5688
+ contentOffset?: PointProp | undefined;
5689
+
5690
+ disableIntervalMomentum?: boolean | undefined;
5691
+
5692
+ decelerationRate?: DecelerationRateType | undefined;
5693
+
5694
+ experimental_endDraggingSensitivityMultiplier?: number | undefined;
5695
+
5696
+ horizontal?: boolean | undefined;
5697
+
5698
+ invertStickyHeaders?: boolean | undefined;
5699
+
5700
+ keyboardDismissMode?: ('none' | 'on-drag' | 'interactive') | undefined;
5701
+
5702
+ keyboardShouldPersistTaps?:
5703
+ | ('always' | 'never' | 'handled' | true | false)
5704
+ | undefined;
5705
+
5706
+ maintainVisibleContentPosition?:
5707
+ | Readonly<{
5708
+ minIndexForVisible: number;
5709
+ autoscrollToTopThreshold?: number | undefined;
5710
+ }>
5711
+ | undefined;
5712
+
5713
+ onMomentumScrollBegin?: ((event: ScrollEvent) => void) | undefined;
5714
+
5715
+ onMomentumScrollEnd?: ((event: ScrollEvent) => void) | undefined;
5716
+
5717
+ onScroll?: ((event: ScrollEvent) => void) | undefined;
5718
+
5719
+ onScrollBeginDrag?: ((event: ScrollEvent) => void) | undefined;
5720
+
5721
+ onScrollEndDrag?: ((event: ScrollEvent) => void) | undefined;
5722
+
5723
+ onContentSizeChange?: (
5724
+ contentWidth: number,
5725
+ contentHeight: number
5726
+ ) => void;
5727
+ onKeyboardDidShow?: (event: KeyboardEvent_2) => void;
5728
+ onKeyboardDidHide?: (event: KeyboardEvent_2) => void;
5729
+ onKeyboardWillShow?: (event: KeyboardEvent_2) => void;
5730
+ onKeyboardWillHide?: (event: KeyboardEvent_2) => void;
5731
+
5732
+ pagingEnabled?: boolean | undefined;
5733
+
5734
+ scrollEnabled?: boolean | undefined;
5735
+
5736
+ scrollEventThrottle?: number | undefined;
5737
+
5738
+ showsVerticalScrollIndicator?: boolean | undefined;
5739
+
5740
+ stickyHeaderHiddenOnScroll?: boolean | undefined;
5741
+
5742
+ stickyHeaderIndices?: ReadonlyArray<number> | undefined;
5743
+
5744
+ StickyHeaderComponent?: StickyHeaderComponentType;
5745
+
5746
+ snapToAlignment?: ('start' | 'center' | 'end') | undefined;
5747
+
5748
+ snapToInterval?: number | undefined;
5749
+
5750
+ snapToOffsets?: ReadonlyArray<number> | undefined;
5751
+
5752
+ snapToStart?: boolean | undefined;
5753
+
5754
+ snapToEnd?: boolean | undefined;
5755
+
5756
+ removeClippedSubviews?: boolean | undefined;
5757
+
5758
+ refreshControl?: React.ReactNode | undefined;
5759
+ children?: React.ReactNode;
5760
+
5761
+ innerViewRef?: React.Ref<InnerViewInstance>;
5762
+
5763
+ scrollViewRef?: React.Ref<PublicScrollViewInstance>;
5764
+ }
5765
+ > & {
5766
+ contentContainerStyle?: ViewStyleProp | undefined;
5767
+
5768
+ contentOffset?: PointProp | undefined;
5769
+
5770
+ disableIntervalMomentum?: boolean | undefined;
5771
+
5772
+ decelerationRate?: DecelerationRateType | undefined;
5773
+
5774
+ experimental_endDraggingSensitivityMultiplier?: number | undefined;
5775
+
5776
+ horizontal?: boolean | undefined;
5777
+
5778
+ invertStickyHeaders?: boolean | undefined;
5779
+
5780
+ keyboardDismissMode?: ('none' | 'on-drag' | 'interactive') | undefined;
5781
+
5782
+ keyboardShouldPersistTaps?:
5783
+ | ('always' | 'never' | 'handled' | true | false)
5784
+ | undefined;
5785
+
5786
+ maintainVisibleContentPosition?:
5787
+ | Readonly<{
5788
+ minIndexForVisible: number;
5789
+ autoscrollToTopThreshold?: number | undefined;
5790
+ }>
5791
+ | undefined;
5792
+
5793
+ onMomentumScrollBegin?: ((event: ScrollEvent) => void) | undefined;
5794
+
5795
+ onMomentumScrollEnd?: ((event: ScrollEvent) => void) | undefined;
5796
+
5797
+ onScroll?: ((event: ScrollEvent) => void) | undefined;
5798
+
5799
+ onScrollBeginDrag?: ((event: ScrollEvent) => void) | undefined;
5800
+
5801
+ onScrollEndDrag?: ((event: ScrollEvent) => void) | undefined;
5802
+
5803
+ onContentSizeChange?: (
5804
+ contentWidth: number,
5805
+ contentHeight: number
5806
+ ) => void;
5807
+ onKeyboardDidShow?: (event: KeyboardEvent_2) => void;
5808
+ onKeyboardDidHide?: (event: KeyboardEvent_2) => void;
5809
+ onKeyboardWillShow?: (event: KeyboardEvent_2) => void;
5810
+ onKeyboardWillHide?: (event: KeyboardEvent_2) => void;
5811
+
5812
+ pagingEnabled?: boolean | undefined;
5813
+
5814
+ scrollEnabled?: boolean | undefined;
5815
+
5816
+ scrollEventThrottle?: number | undefined;
5817
+
5818
+ showsVerticalScrollIndicator?: boolean | undefined;
5819
+
5820
+ stickyHeaderHiddenOnScroll?: boolean | undefined;
5821
+
5822
+ stickyHeaderIndices?: ReadonlyArray<number> | undefined;
5823
+
5824
+ StickyHeaderComponent?: StickyHeaderComponentType;
5825
+
5826
+ snapToAlignment?: ('start' | 'center' | 'end') | undefined;
5827
+
5828
+ snapToInterval?: number | undefined;
5829
+
5830
+ snapToOffsets?: ReadonlyArray<number> | undefined;
5831
+
5832
+ snapToStart?: boolean | undefined;
5833
+
5834
+ snapToEnd?: boolean | undefined;
5835
+
5836
+ removeClippedSubviews?: boolean | undefined;
5837
+
5838
+ refreshControl?: React.ReactNode | undefined;
5839
+ children?: React.ReactNode;
5840
+
5841
+ innerViewRef?: React.Ref<InnerViewInstance>;
5842
+
5843
+ scrollViewRef?: React.Ref<PublicScrollViewInstance>;
5844
+ }
5845
+ >;
5846
+
5847
+ export declare type ScrollViewPropsAndroid = Readonly<{
5848
+ nestedScrollEnabled?: boolean | undefined;
5849
+
5850
  endFillColor?: ColorValue | undefined;
5851
+
5852
  scrollPerfTag?: string | undefined;
5853
+
5854
+ overScrollMode?: ('auto' | 'always' | 'never') | undefined;
5855
+
 
5856
  persistentScrollbar?: boolean | undefined;
5857
+
5858
+ fadingEdgeLength?: number | undefined;
5859
+ }>;
5860
+
5861
+ export declare type ScrollViewPropsIOS = Readonly<{
 
 
5862
+ automaticallyAdjustContentInsets?: boolean | undefined;
5863
+
5864
  automaticallyAdjustKeyboardInsets?: boolean | undefined;
5865
+
5866
  automaticallyAdjustsScrollIndicatorInsets?: boolean | undefined;
5867
+
5868
+ contentInset?: EdgeInsetsProp | undefined;
5869
+
5870
  bounces?: boolean | undefined;
5871
+
5872
+ disableScrollViewPanResponder?: boolean | undefined;
5873
+
5874
  bouncesZoom?: boolean | undefined;
5875
+
5876
+ alwaysBounceHorizontal?: boolean | undefined;
5877
+
5878
+ alwaysBounceVertical?: boolean | undefined;
5879
+
5880
  centerContent?: boolean | undefined;
5881
+
5882
+ indicatorStyle?: ('default' | 'black' | 'white') | undefined;
5883
+
 
 
 
 
 
5884
  directionalLockEnabled?: boolean | undefined;
5885
+
 
 
 
5886
+ canCancelContentTouches?: boolean | undefined;
5887
+
 
 
5888
  maximumZoomScale?: number | undefined;
5889
+
5890
  minimumZoomScale?: number | undefined;
5891
+
5892
  pinchGestureEnabled?: boolean | undefined;
5893
+
5894
+ scrollIndicatorInsets?: EdgeInsetsProp | undefined;
5895
+
5896
  scrollToOverflowEnabled?: boolean | undefined;
5897
+
5898
  scrollsToTop?: boolean | undefined;
5899
+
 
5900
+ onScrollToTop?: (event: ScrollEvent) => void;
5901
+
5902
+ showsHorizontalScrollIndicator?: boolean | undefined;
5903
+
5904
  zoomScale?: number | undefined;
5905
+
5906
+ contentInsetAdjustmentBehavior?:
5907
+ | ('automatic' | 'scrollableAxes' | 'never' | 'always')
5908
+ | undefined;
5909
+ }>;
5910
+
5911
+ declare interface ScrollViewScrollToOptions {
5912
+ x?: number;
5913
+ y?: number;
5914
+ animated?: boolean;
5915
  }
5916
+
5917
+ declare type ScrollViewStickyHeaderProps = Readonly<{
5918
+ children?: React.ReactNode;
5919
+ nextHeaderLayoutY: number | undefined;
5920
+ onLayout: (event: LayoutChangeEvent) => void;
5921
+ scrollAnimatedValue: Animated.Value;
5922
+ inverted: boolean | undefined;
5923
+ scrollViewHeight: number | undefined;
5924
+ nativeID?: string | undefined;
5925
+ hiddenOnScroll?: boolean | undefined;
5926
+ }>;
5927
+
5928
+ export {SectionBase};
5929
+
5930
+ declare type SectionBase_2<
5931
+ SectionItemT,
5932
+ SectionT = DefaultSectionT,
5933
+ > = SectionBase<SectionItemT, SectionT>;
5934
+
 
 
5935
  export declare class SectionList<
5936
+ ItemT,
5937
  SectionT = DefaultSectionT,
5938
+ > extends React.PureComponent<SectionListProps<ItemT, SectionT>> {
5939
+ props: SectionListProps<ItemT, SectionT>;
 
 
5940
+ scrollToLocation(params: ScrollToLocationParamsType): void;
5941
  recordInteraction(): void;
5942
  flashScrollIndicators(): void;
5943
+ getScrollResponder(): null | undefined | ScrollResponderType;
5944
+ getScrollableNode(): any;
5945
+ setNativeProps(props: Object): void;
5946
+ render(): React.ReactNode;
5947
  }
5948
+
 
 
 
 
5949
+ export declare type SectionListProps<ItemT, SectionT = DefaultSectionT> = Omit<
 
 
 
 
5950
+ Omit<
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5951
+ VirtualizedSectionListProps<ItemT, SectionT>,
5952
+ 'getItem' | 'getItemCount' | 'renderItem' | 'keyExtractor'
5953
+ >,
5954
+ keyof (
5955
+ | RequiredProps_2<ItemT, SectionT>
 
 
 
5956
+ | OptionalProps_2<ItemT, SectionT>
5957
+ | {}
5958
+ )
5959
+ > &
5960
+ Omit<
5961
+ RequiredProps_2<ItemT, SectionT>,
 
5962
+ keyof (OptionalProps_2<ItemT, SectionT> | {})
5963
+ > &
5964
+ Omit<OptionalProps_2<ItemT, SectionT>, keyof {}> & {};
5965
+
 
 
 
 
5966
  export declare type SectionListRenderItem<ItemT, SectionT = DefaultSectionT> = (
5967
  info: SectionListRenderItemInfo<ItemT, SectionT>
5968
+ ) => React.ReactNode | null;
5969
+
5970
+ export declare type SectionListRenderItemInfo<
5971
  ItemT,
5972
  SectionT = DefaultSectionT,
5973
+ > = Omit<
5974
+ ListRenderItemInfo<ItemT>,
5975
+ keyof {
5976
+ section: SectionData<ItemT, SectionT>;
5977
+ }
5978
+ > & {
5979
+ section: SectionData<ItemT, SectionT>;
5980
+ };
5981
+
5982
+ declare type Selection_2 = Readonly<{
5983
+ start: number;
5984
+ end: number;
5985
+ }>;
5986
+
5987
+ declare type Selection_3 = Readonly<{
5988
+ start: number;
5989
+ end: number;
5990
+ }>;
5991
+
5992
+ export {Separators};
5993
+
5994
+ declare const sequence: (
5995
+ animations: Array<CompositeAnimation>
5996
+ ) => CompositeAnimation;
5997
+
5998
+ declare const sequence_2: typeof AnimatedImplementation_MODULE_EXPORT.sequence;
5999
+
6000
+ declare type sequence_2 = typeof sequence_2;
6001
+
6002
+ declare function setColorScheme(
6003
+ colorScheme: null | undefined | ColorSchemeName
6004
+ ): void;
6005
+
6006
+ declare function setComponentProviderInstrumentationHook(
6007
+ hook: ComponentProviderInstrumentationHook
6008
+ ): void;
6009
+
6010
+ declare function setEnabled(value: boolean): void;
6011
+
6012
+ declare function setEnabled_2(_doEnable: boolean): void;
6013
+
6014
+ declare function setRootViewStyleProvider(
6015
+ provider: RootViewStyleProvider
6016
+ ): void;
6017
+
6018
+ declare const setStyleAttributePreprocessor: (
6019
+ property: string,
6020
+ process: (nextProp: any) => any
6021
+ ) => void;
6022
+
6023
+ declare type setStyleAttributePreprocessor =
6024
+ typeof setStyleAttributePreprocessor;
6025
+
6026
+ declare function setSurfaceProps(
6027
+ appKey: string,
6028
+ appParameters: Object,
6029
+ displayMode?: number
6030
+ ): void;
6031
+
6032
+ export declare const Settings: typeof Settings_2;
6033
+
6034
+ export declare type Settings = typeof Settings;
6035
+
6036
+ declare const Settings_2: {
6037
  get(key: string): any;
6038
  set(settings: Object): void;
6039
  watchKeys(keys: string | Array<string>, callback: () => void): number;
6040
  clearWatch(watchId: number): void;
6041
+ };
6042
+
6043
+ declare function setWrapperComponentProvider(
6044
+ provider: WrapperComponentProvider
6045
+ ): void;
6046
+
6047
+ export declare class Share {
6048
+ static share(
6049
+ content: ShareContent,
6050
+ options?: ShareOptions
6051
+ ): Promise<{
6052
+ action: string;
6053
+ activityType: string | undefined;
6054
+ }>;
6055
+ static sharedAction: 'sharedAction';
6056
+ static dismissedAction: 'dismissedAction';
6057
  }
6058
+
 
 
 
 
 
 
 
6059
  export declare type ShareAction = {
6060
  action: 'sharedAction' | 'dismissedAction';
6061
+ activityType?: string | null;
6062
  };
6063
+
6064
+ export declare type ShareActionSheetError = Readonly<{
6065
+ domain: string;
6066
+ code: string;
6067
+ userInfo?: Object | undefined;
6068
+ message: string;
6069
+ }>;
6070
+
6071
+ export declare type ShareActionSheetIOSOptions = Readonly<{
6072
  message?: string | undefined;
6073
  url?: string | undefined;
6074
  subject?: string | undefined;
6075
  anchor?: number | undefined;
6076
+ tintColor?: number | undefined;
6077
+ cancelButtonTintColor?: number | undefined;
6078
+ disabledButtonTintColor?: number | undefined;
6079
+ excludedActivityTypes?: Array<string> | undefined;
6080
+ userInterfaceStyle?: string | undefined;
6081
+ }>;
6082
+
6083
  export declare type ShareContent =
6084
  | {
6085
+ title?: string;
6086
  url: string;
6087
+ message?: string;
6088
  }
6089
  | {
6090
+ title?: string;
6091
+ url?: string;
6092
  message: string;
6093
  };
6094
+
6095
  export declare type ShareOptions = {
6096
+ dialogTitle?: string;
6097
+ excludedActivityTypes?: Array<string>;
6098
+ tintColor?: ColorValue;
6099
+ subject?: string;
6100
+ anchor?: number;
6101
  };
6102
+
 
 
 
 
6103
  export declare type SimpleTask = {
6104
  name: string;
6105
+ run: () => void;
6106
  };
6107
+
6108
+ declare interface Spec extends TurboModule {
6109
+ readonly getConstants: () => {
6110
+ readonly buttonClicked: DialogAction;
6111
+ readonly dismissed: DialogAction;
6112
+ readonly buttonPositive: DialogButtonKey;
6113
+ readonly buttonNegative: DialogButtonKey;
6114
+ readonly buttonNeutral: DialogButtonKey;
6115
+ };
6116
+ readonly showAlert: (
6117
+ config: DialogOptions,
6118
+ onError: (error: string) => void,
6119
+ onAction: (action: DialogAction, buttonKey?: DialogButtonKey) => void
6120
+ ) => void;
6121
  }
6122
+
6123
+ declare interface Spec_2 extends TurboModule {
6124
+ readonly getConstants: () => Object;
6125
+ readonly createView: (
6126
+ reactTag: number,
6127
+ viewName: string,
6128
+ rootTag: RootTag,
6129
+ props: Object
6130
+ ) => void;
6131
+ readonly updateView: (
6132
+ reactTag: number,
6133
+ viewName: string,
6134
+ props: Object
6135
+ ) => void;
6136
+ readonly findSubviewIn: (
6137
+ reactTag: number,
6138
+ point: Array<number>,
6139
+ callback: (
6140
+ nativeViewTag: number,
6141
+ left: number,
6142
+ top: number,
6143
+ width: number,
6144
+ height: number
6145
+ ) => void
6146
+ ) => void;
6147
+
6148
+ readonly dispatchViewManagerCommand: (
6149
+ reactTag: number,
6150
+ commandID: number,
6151
+ commandArgs?: Array<any>
6152
+ ) => void;
6153
+
6154
+ readonly measure: (
6155
+ reactTag: number,
6156
+ callback: MeasureOnSuccessCallback_2
6157
+ ) => void;
6158
+
6159
+ readonly measureInWindow: (
6160
+ reactTag: number,
6161
+ callback: MeasureInWindowOnSuccessCallback_2
6162
+ ) => void;
6163
+ readonly viewIsDescendantOf: (
6164
+ reactTag: number,
6165
+ ancestorReactTag: number,
6166
+ callback: (result: Array<boolean>) => void
6167
+ ) => void;
6168
+
6169
+ readonly measureLayout: (
6170
+ reactTag: number,
6171
+ ancestorReactTag: number,
6172
+ errorCallback: (error: Object) => void,
6173
+ callback: MeasureLayoutOnSuccessCallback_2
6174
+ ) => void;
6175
+ readonly measureLayoutRelativeToParent: (
6176
+ reactTag: number,
6177
+ errorCallback: (error: Object) => void,
6178
+ callback: (left: number, top: number, width: number, height: number) => void
6179
+ ) => void;
6180
+ readonly setJSResponder: (
6181
+ reactTag: number,
6182
+ blockNativeResponder: boolean
6183
+ ) => void;
6184
+ readonly clearJSResponder: () => void;
6185
+ readonly configureNextLayoutAnimation: (
6186
+ config: Object,
6187
+ callback: () => void,
6188
+ errorCallback: (error: Object) => void
6189
+ ) => void;
6190
+ readonly setChildren: (
6191
+ containerTag: number,
6192
+ reactTags: Array<number>
6193
+ ) => void;
6194
+ readonly manageChildren: (
6195
+ containerTag: number,
6196
+ moveFromIndices: Array<number>,
6197
+ moveToIndices: Array<number>,
6198
+ addChildReactTags: Array<number>,
6199
+ addAtIndices: Array<number>,
6200
+ removeAtIndices: Array<number>
6201
+ ) => void;
6202
+ readonly getConstantsForViewManager?: (
6203
+ viewManagerName: string
6204
+ ) => Object | undefined;
6205
+ readonly getDefaultEventTypes?: () => Array<string>;
6206
+
6207
+ readonly setLayoutAnimationEnabledExperimental?: (enabled: boolean) => void;
6208
+ readonly sendAccessibilityEvent?: (
6209
+ reactTag: number,
6210
+ eventType: number
6211
+ ) => void;
6212
+ readonly lazilyLoadView?: (name: string) => Object;
6213
+ readonly focus?: (reactTag: number) => void;
6214
+ readonly blur?: (reactTag: number) => void;
6215
  }
6216
+
6217
+ declare const spring: (
6218
+ value: AnimatedValue | AnimatedValueXY | AnimatedColor,
6219
+ config: SpringAnimationConfig
6220
+ ) => CompositeAnimation;
6221
+
6222
+ declare const spring_2: typeof AnimatedImplementation_MODULE_EXPORT.spring;
6223
+
6224
+ declare type spring_2 = typeof spring_2;
6225
+
6226
+ declare type SpringAnimationConfig = Readonly<
6227
+ Omit<
6228
+ AnimationConfig,
6229
+ keyof {
6230
+ toValue:
6231
+ | number
6232
+ | AnimatedValue
6233
+ | {
6234
+ x: number;
6235
+ y: number;
6236
+ }
6237
+ | AnimatedValueXY
6238
+ | {
6239
+ r: number;
6240
+ g: number;
6241
+ b: number;
6242
+ a: number;
6243
+ }
6244
+ | AnimatedColor
6245
+ | AnimatedInterpolation<number>;
6246
+ overshootClamping?: boolean;
6247
+ restDisplacementThreshold?: number;
6248
+ restSpeedThreshold?: number;
6249
+ velocity?:
6250
+ | number
6251
+ | Readonly<{
6252
+ x: number;
6253
+ y: number;
6254
+ }>;
6255
+ bounciness?: number;
6256
+ speed?: number;
6257
+ tension?: number;
6258
+ friction?: number;
6259
+ stiffness?: number;
6260
+ damping?: number;
6261
+ mass?: number;
6262
+ delay?: number;
6263
+ }
6264
+ > & {
6265
+ toValue:
6266
+ | number
6267
+ | AnimatedValue
6268
+ | {
6269
+ x: number;
6270
+ y: number;
6271
+ }
6272
+ | AnimatedValueXY
6273
+ | {
6274
+ r: number;
6275
+ g: number;
6276
+ b: number;
6277
+ a: number;
6278
+ }
6279
+ | AnimatedColor
6280
+ | AnimatedInterpolation<number>;
6281
+ overshootClamping?: boolean;
6282
+ restDisplacementThreshold?: number;
6283
+ restSpeedThreshold?: number;
6284
+ velocity?:
6285
+ | number
6286
+ | Readonly<{
6287
+ x: number;
6288
+ y: number;
6289
+ }>;
6290
+ bounciness?: number;
6291
+ speed?: number;
6292
+ tension?: number;
6293
+ friction?: number;
6294
+ stiffness?: number;
6295
+ damping?: number;
6296
+ mass?: number;
6297
+ delay?: number;
6298
+ }
6299
+ >;
6300
+
6301
+ declare type StackFrame = {
6302
+ column: number | undefined;
6303
+ file: string | undefined;
6304
+ lineNumber: number | undefined;
6305
+ methodName: string;
6306
+ collapse?: boolean;
6307
+ };
6308
+
6309
+ declare type StackProps = {
6310
+ backgroundColor:
6311
+ | {
6312
+ value: StatusBarProps['backgroundColor'];
6313
+ animated: boolean;
6314
+ }
6315
+ | undefined;
6316
+ barStyle:
6317
+ | {
6318
+ value: StatusBarProps['barStyle'];
6319
+ animated: boolean;
6320
+ }
6321
+ | undefined;
6322
+ translucent: StatusBarProps['translucent'];
6323
+ hidden:
6324
+ | {
6325
+ value: boolean;
6326
+ animated: boolean;
6327
+ transition: StatusBarProps['showHideTransition'];
6328
+ }
6329
+ | undefined;
6330
+ networkActivityIndicatorVisible: StatusBarProps['networkActivityIndicatorVisible'];
6331
+ };
6332
+
6333
+ declare const stagger: (
6334
+ time: number,
6335
+ animations: Array<CompositeAnimation>
6336
+ ) => CompositeAnimation;
6337
+
6338
+ declare const stagger_2: typeof AnimatedImplementation_MODULE_EXPORT.stagger;
6339
+
6340
+ declare type stagger_2 = typeof stagger_2;
6341
+
6342
+ declare function startHeadlessTask(
6343
+ taskId: number,
6344
+ taskKey: string,
6345
+ data: any
6346
+ ): void;
6347
+
6348
+ declare type State = Readonly<{
6349
+ pressability: Pressability;
6350
+ }>;
6351
+
6352
+ declare type State_2 = {
6353
+ layoutHeight: number | undefined;
6354
+ };
6355
+
6356
+ declare type State_3 = {
6357
+ bottom: number;
6358
+ };
6359
+
6360
+ declare type State_4 =
6361
+ | typeof States.NOT_RESPONDER
6362
+ | typeof States.RESPONDER_INACTIVE_PRESS_IN
6363
+ | typeof States.RESPONDER_INACTIVE_PRESS_OUT
6364
+ | typeof States.RESPONDER_ACTIVE_PRESS_IN
6365
+ | typeof States.RESPONDER_ACTIVE_PRESS_OUT
6366
+ | typeof States.RESPONDER_ACTIVE_LONG_PRESS_IN
6367
+ | typeof States.RESPONDER_ACTIVE_LONG_PRESS_OUT
6368
+ | typeof States.ERROR;
6369
+
6370
+ declare const States: {
6371
+ NOT_RESPONDER: 'NOT_RESPONDER';
6372
+ RESPONDER_INACTIVE_PRESS_IN: 'RESPONDER_INACTIVE_PRESS_IN';
6373
+ RESPONDER_INACTIVE_PRESS_OUT: 'RESPONDER_INACTIVE_PRESS_OUT';
6374
+ RESPONDER_ACTIVE_PRESS_IN: 'RESPONDER_ACTIVE_PRESS_IN';
6375
+ RESPONDER_ACTIVE_PRESS_OUT: 'RESPONDER_ACTIVE_PRESS_OUT';
6376
+ RESPONDER_ACTIVE_LONG_PRESS_IN: 'RESPONDER_ACTIVE_LONG_PRESS_IN';
6377
+ RESPONDER_ACTIVE_LONG_PRESS_OUT: 'RESPONDER_ACTIVE_LONG_PRESS_OUT';
6378
+ ERROR: 'ERROR';
6379
+ };
6380
+
6381
+ export declare class StatusBar extends React.Component<StatusBarProps> {
6382
+ static currentHeight: null | undefined | number;
6383
+ static setHidden(hidden: boolean, animation?: StatusBarAnimation): void;
6384
+ static setBarStyle(style: StatusBarStyle, animated?: boolean): void;
6385
+ static setNetworkActivityIndicatorVisible(visible: boolean): void;
6386
+ static setBackgroundColor(color: ColorValue, animated?: boolean): void;
6387
+ static setTranslucent(translucent: boolean): void;
6388
+ static pushStackEntry(props: StatusBarProps): StackProps;
6389
+ static popStackEntry(entry: StackProps): void;
6390
+ static replaceStackEntry(
6391
+ entry: StackProps,
6392
  props: StatusBarProps
6393
+ ): StackProps;
6394
+ componentDidMount(): void;
6395
+ componentWillUnmount(): void;
6396
+ componentDidUpdate(): void;
6397
+ render(): React.ReactNode;
6398
  }
6399
+
6400
+ export declare type StatusBarAnimation = keyof {
6401
+ none: string;
6402
+
6403
+ fade: string;
6404
+
6405
+ slide: string;
6406
+ };
6407
+
6408
+ declare type StatusBarBaseProps = Readonly<{
 
 
 
 
 
6409
  hidden?: boolean | undefined;
6410
+
6411
+ animated?: boolean | undefined;
6412
+
6413
+ barStyle?: ('default' | 'light-content' | 'dark-content') | undefined;
6414
+ }>;
6415
+
6416
+ export declare type StatusBarProps = Readonly<
6417
+ Omit<
6418
+ StatusBarPropsAndroid,
6419
+ keyof (StatusBarPropsIOS | StatusBarBaseProps | {})
6420
+ > &
6421
+ Omit<StatusBarPropsIOS, keyof (StatusBarBaseProps | {})> &
6422
+ Omit<StatusBarBaseProps, keyof {}> & {}
6423
+ >;
6424
+
6425
+ declare type StatusBarPropsAndroid = Readonly<{
6426
  backgroundColor?: ColorValue | undefined;
6427
+
6428
  translucent?: boolean | undefined;
6429
+ }>;
6430
+
6431
+ declare type StatusBarPropsIOS = Readonly<{
6432
  networkActivityIndicatorVisible?: boolean | undefined;
6433
+
6434
+ showHideTransition?: ('fade' | 'slide' | 'none') | undefined;
6435
+ }>;
6436
+
6437
+ export declare type StatusBarStyle = keyof {
6438
+ default: string;
6439
+
6440
+ 'light-content': string;
6441
+
6442
+ 'dark-content': string;
6443
+ };
6444
+
6445
+ declare type StickyHeaderComponentType = (
6446
+ props: Omit<
6447
+ ScrollViewStickyHeaderProps,
6448
+ keyof {
6449
+ ref?: React.Ref<
6450
+ Readonly<{
6451
+ setNextHeaderY: ($$PARAM_0$$: number) => void;
6452
+ }>
6453
+ >;
6454
+ }
6455
+ > & {
6456
+ ref?: React.Ref<
6457
+ Readonly<{
6458
+ setNextHeaderY: ($$PARAM_0$$: number) => void;
6459
+ }>
6460
+ >;
6461
+ }
6462
+ ) => React.ReactNode;
6463
+
6464
  export declare type StyleProp<T> =
6465
+ | null
6466
+ | void
6467
  | T
 
 
6468
+ | false
6469
+ | ''
6470
+ | ReadonlyArray<StyleProp<T>>;
6471
+
6472
+ export declare namespace StyleSheet_2 {
6473
+ export {
6474
+ hairlineWidth,
6475
+ absoluteFill,
6476
+ absoluteFillObject,
6477
+ compose,
6478
+ flatten,
6479
+ setStyleAttributePreprocessor,
6480
+ create_2 as create,
6481
  };
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6482
  }
6483
+
 
 
 
6484
  export declare type SubmitBehavior = 'submit' | 'blurAndSubmit' | 'newline';
6485
+
6486
+ declare type SubmitBehavior_2 = 'submit' | 'blurAndSubmit' | 'newline';
6487
+
6488
+ declare const subtract: (
6489
+ a: AnimatedNode | number,
6490
+ b: AnimatedNode | number
6491
+ ) => AnimatedSubtraction;
6492
+
6493
+ declare const subtract_2: typeof AnimatedImplementation_MODULE_EXPORT.subtract;
6494
+
6495
+ declare type subtract_2 = typeof subtract_2;
6496
+
6497
+ export declare const Switch: typeof Switch_2;
6498
+
6499
+ export declare type Switch = typeof Switch;
6500
+
 
 
6501
+ declare const Switch_2: (
6502
+ props: Omit<
6503
+ SwitchProps,
6504
+ keyof {
6505
+ ref?: React.Ref<SwitchRef>;
6506
+ }
6507
+ > & {
6508
+ ref?: React.Ref<SwitchRef>;
6509
+ }
6510
+ ) => React.ReactNode;
6511
+
6512
+ export declare type SwitchChangeEvent =
6513
+ NativeSyntheticEvent<SwitchChangeEventData>;
6514
+
6515
+ declare type SwitchChangeEvent_2 = Readonly<{
6516
  value: boolean;
6517
+ target: Int32;
6518
+ }>;
6519
+
6520
+ declare type SwitchChangeEvent_3 = Readonly<{
6521
+ value: boolean;
6522
+ target: Int32;
6523
+ }>;
6524
+
6525
+ declare type SwitchChangeEventData = Readonly<{
6526
+ target: number;
6527
+ value: boolean;
6528
+ }>;
6529
+
6530
+ declare const SwitchNativeComponent_MODULE_EXPORT: typeof SwitchNativeComponent_MODULE_EXPORT_2;
6531
+
6532
+ declare type SwitchNativeComponent_MODULE_EXPORT =
6533
+ typeof SwitchNativeComponent_MODULE_EXPORT;
6534
+
6535
+ declare const SwitchNativeComponent_MODULE_EXPORT_2: ComponentType;
6536
+
6537
+ declare type SwitchNativeComponent_MODULE_EXPORT_2 =
6538
+ typeof SwitchNativeComponent_MODULE_EXPORT_2;
6539
+
6540
+ export declare type SwitchProps = Readonly<
6541
+ Omit<ViewProps, keyof (SwitchPropsIOS | SwitchPropsBase | {})> &
6542
+ Omit<SwitchPropsIOS, keyof (SwitchPropsBase | {})> &
6543
+ Omit<SwitchPropsBase, keyof {}> & {}
6544
+ >;
6545
+
6546
+ declare type SwitchPropsBase = {
6547
+ disabled?: boolean | undefined;
6548
+
6549
+ value?: boolean | undefined;
6550
+
6551
  thumbColor?: ColorValue | undefined;
6552
+
6553
  trackColor?:
6554
+ | Readonly<{
6555
+ false?: ColorValue | undefined;
6556
+ true?: ColorValue | undefined;
6557
+ }>
6558
  | undefined;
6559
+
 
 
 
 
 
 
 
6560
  ios_backgroundColor?: ColorValue | undefined;
6561
+
6562
+ onChange?: ((event: SwitchChangeEvent) => Promise<void> | void) | undefined;
6563
+
6564
+ onValueChange?: ((value: boolean) => Promise<void> | void) | undefined;
6565
+ };
6566
+
6567
+ declare type SwitchPropsIOS = {
6568
  onTintColor?: ColorValue | undefined;
6569
+
6570
  thumbTintColor?: ColorValue | undefined;
6571
+
6572
  tintColor?: ColorValue | undefined;
6573
+ };
6574
+
6575
+ declare type SwitchRef = React.ComponentRef<
6576
+ | typeof SwitchNativeComponent_MODULE_EXPORT
6577
+ | typeof AndroidSwitchNativeComponent_MODULE_EXPORT
6578
+ >;
6579
+
6580
  export declare namespace Systrace {
6581
  export {
6582
  isEnabled,
6583
+ setEnabled_2 as setEnabled,
6584
  beginEvent,
6585
  endEvent,
6586
  beginAsyncEvent,
6587
  endAsyncEvent,
 
6589
  EventName,
6590
  EventArgs,
6591
  };
6592
  }
6593
+
6594
+ export declare type TargetedEvent = Readonly<{
6595
  target: number;
6596
+ }>;
6597
+
6598
+ declare type TargetEvent = Readonly<{
6599
+ target: number;
6600
+ }>;
6601
+
6602
+ declare type TargetEvent_2 = Readonly<{
6603
+ target: number;
6604
+ }>;
6605
+
6606
+ declare type Task = (taskData: any) => Promise<void>;
6607
+
6608
+ declare type Task_2 = SimpleTask | PromiseTask | (() => void);
6609
+
6610
+ declare type TaskCanceller = () => void;
6611
+
6612
+ declare type TaskCancelProvider = () => TaskCanceller;
6613
+
6614
  export declare type TaskProvider = () => Task;
6615
+
6616
+ declare type TBackHandler = {
6617
+ exitApp(): void;
6618
+ addEventListener(
6619
+ eventName: BackPressEventName,
6620
+ handler: () => boolean | undefined
6621
+ ): {
6622
+ remove: () => void;
6623
+ };
6624
+ };
6625
+
6626
+ declare const Text_2: typeof Text_3;
6627
+
6628
+ declare type Text_2 = typeof Text_2;
6629
  export {Text_2 as Text};
6630
+
 
 
 
 
 
6631
+ declare const Text_3: (
6632
+ props: Omit<
6633
+ TextProps,
6634
+ keyof {
6635
+ ref?: React.Ref<TextForwardRef>;
6636
+ }
6637
+ > & {
6638
+ ref?: React.Ref<TextForwardRef>;
6639
+ }
6640
+ ) => React.ReactNode;
6641
+
6642
+ declare type TextBaseProps = Readonly<{
 
6643
+ accessible?: boolean | undefined;
6644
+ accessibilityActions?: ReadonlyArray<AccessibilityActionInfo> | undefined;
6645
+ onAccessibilityAction?:
 
 
 
 
6646
+ | ((event: AccessibilityActionEvent) => unknown)
6647
  | undefined;
6648
+ accessibilityHint?: string | undefined;
6649
+ accessibilityLanguage?: string | undefined;
6650
+ accessibilityLabel?: string | undefined;
6651
+ accessibilityRole?: AccessibilityRole | undefined;
6652
+ accessibilityState?: AccessibilityState | undefined;
6653
+ 'aria-label'?: string | undefined;
6654
+
6655
+ allowFontScaling?: boolean | undefined;
6656
+
6657
+ android_hyphenationFrequency?: ('normal' | 'none' | 'full') | undefined;
6658
+
6659
+ 'aria-busy'?: boolean | undefined;
6660
+ 'aria-checked'?: (boolean | undefined) | 'mixed';
6661
+ 'aria-disabled'?: boolean | undefined;
6662
+ 'aria-expanded'?: boolean | undefined;
6663
+ 'aria-selected'?: boolean | undefined;
6664
+
6665
+ 'aria-labelledby'?: string | undefined;
6666
+ children?: React.ReactNode | undefined;
6667
+
6668
+ ellipsizeMode?: ('clip' | 'head' | 'middle' | 'tail') | undefined;
6669
+
6670
+ id?: string;
6671
+
6672
+ maxFontSizeMultiplier?: number | undefined;
6673
+
6674
+ nativeID?: string | undefined;
6675
+
6676
+ numberOfLines?: number | undefined;
6677
+
6678
+ onLayout?: ((event: LayoutChangeEvent) => unknown) | undefined;
6679
+
6680
+ onLongPress?: ((event: GestureResponderEvent) => unknown) | undefined;
6681
+
6682
+ onPress?: ((event: GestureResponderEvent) => unknown) | undefined;
6683
+ onPressIn?: ((event: GestureResponderEvent) => unknown) | undefined;
6684
+ onPressOut?: ((event: GestureResponderEvent) => unknown) | undefined;
6685
+ onResponderGrant?: ((event: GestureResponderEvent) => void) | undefined;
6686
+ onResponderMove?: ((event: GestureResponderEvent) => void) | undefined;
6687
+ onResponderRelease?: ((event: GestureResponderEvent) => void) | undefined;
6688
+ onResponderTerminate?: ((event: GestureResponderEvent) => void) | undefined;
6689
+ onResponderTerminationRequest?: (() => boolean) | undefined;
6690
+ onStartShouldSetResponder?: (() => boolean) | undefined;
6691
+ onMoveShouldSetResponder?: (() => boolean) | undefined;
6692
+ onTextLayout?: ((event: TextLayoutEvent) => unknown) | undefined;
6693
+
6694
+ pressRetentionOffset?: PressRetentionOffset | undefined;
6695
+
6696
+ role?: Role | undefined;
6697
+
6698
+ selectable?: boolean | undefined;
6699
+
6700
+ style?: TextStyleProp | undefined;
6701
+
6702
+ testID?: string | undefined;
6703
+ }>;
6704
+
6705
+ export declare type TextContentType =
6706
+ | 'none'
6707
+ | 'URL'
6708
+ | 'addressCity'
6709
+ | 'addressCityAndState'
6710
+ | 'addressState'
6711
+ | 'countryName'
6712
+ | 'creditCardNumber'
6713
+ | 'creditCardExpiration'
6714
+ | 'creditCardExpirationMonth'
6715
+ | 'creditCardExpirationYear'
6716
+ | 'creditCardSecurityCode'
6717
+ | 'creditCardType'
6718
+ | 'creditCardName'
6719
+ | 'creditCardGivenName'
6720
+ | 'creditCardMiddleName'
6721
+ | 'creditCardFamilyName'
6722
+ | 'emailAddress'
6723
+ | 'familyName'
6724
+ | 'fullStreetAddress'
6725
+ | 'givenName'
6726
+ | 'jobTitle'
6727
+ | 'location'
6728
+ | 'middleName'
6729
+ | 'name'
6730
+ | 'namePrefix'
6731
+ | 'nameSuffix'
6732
+ | 'nickname'
6733
+ | 'organizationName'
6734
+ | 'postalCode'
6735
+ | 'streetAddressLine1'
6736
+ | 'streetAddressLine2'
6737
+ | 'sublocality'
6738
+ | 'telephoneNumber'
6739
+ | 'username'
6740
+ | 'password'
6741
+ | 'newPassword'
6742
+ | 'oneTimeCode'
6743
+ | 'birthdate'
6744
+ | 'birthdateDay'
6745
+ | 'birthdateMonth'
6746
+ | 'birthdateYear'
6747
+ | 'cellularEID'
6748
+ | 'cellularIMEI'
6749
+ | 'dateTime'
6750
+ | 'flightNumber'
6751
+ | 'shipmentTrackingNumber';
6752
+
6753
+ declare type TextContentType_2 =
6754
+ | 'none'
6755
+ | 'URL'
6756
+ | 'addressCity'
6757
+ | 'addressCityAndState'
6758
+ | 'addressState'
6759
+ | 'countryName'
6760
+ | 'creditCardNumber'
6761
+ | 'creditCardExpiration'
6762
+ | 'creditCardExpirationMonth'
6763
+ | 'creditCardExpirationYear'
6764
+ | 'creditCardSecurityCode'
6765
+ | 'creditCardType'
6766
+ | 'creditCardName'
6767
+ | 'creditCardGivenName'
6768
+ | 'creditCardMiddleName'
6769
+ | 'creditCardFamilyName'
6770
+ | 'emailAddress'
6771
+ | 'familyName'
6772
+ | 'fullStreetAddress'
6773
+ | 'givenName'
6774
+ | 'jobTitle'
6775
+ | 'location'
6776
+ | 'middleName'
6777
+ | 'name'
6778
+ | 'namePrefix'
6779
+ | 'nameSuffix'
6780
+ | 'nickname'
6781
+ | 'organizationName'
6782
+ | 'postalCode'
6783
+ | 'streetAddressLine1'
6784
+ | 'streetAddressLine2'
6785
+ | 'sublocality'
6786
+ | 'telephoneNumber'
6787
+ | 'username'
6788
+ | 'password'
6789
+ | 'newPassword'
6790
+ | 'oneTimeCode'
6791
+ | 'birthdate'
6792
+ | 'birthdateDay'
6793
+ | 'birthdateMonth'
6794
+ | 'birthdateYear'
6795
+ | 'cellularEID'
6796
+ | 'cellularIMEI'
6797
+ | 'dateTime'
6798
+ | 'flightNumber'
6799
+ | 'shipmentTrackingNumber';
6800
+
6801
+ declare type TextForwardRef = React.ComponentRef<
6802
+ typeof NativeText | typeof NativeVirtualText
6803
+ >;
6804
+
6805
+ declare const TextInlineImage: HostComponent<NativeProps>;
6806
+
6807
+ declare type TextInlineImageNativeComponent =
6808
+ typeof TextInlineImageNativeComponent_MODULE_EXPORT;
6809
+
6810
+ declare const TextInlineImageNativeComponent_MODULE_EXPORT: typeof TextInlineImage;
6811
+
6812
+ declare type TextInlineImageNativeComponent_MODULE_EXPORT =
6813
+ typeof TextInlineImageNativeComponent_MODULE_EXPORT;
6814
+
6815
+ export declare const TextInput: TextInputType;
6816
+
6817
+ export declare type TextInput = typeof TextInput;
6818
+
6819
+ export declare type TextInputAndroidProps = Readonly<{
6820
+ cursorColor?: ColorValue | undefined;
6821
+
6822
  disableFullscreenUI?: boolean | undefined;
6823
+
6824
+ importantForAutofill?:
6825
+ | ('auto' | 'no' | 'noExcludeDescendants' | 'yes' | 'yesExcludeDescendants')
6826
+ | undefined;
6827
+
6828
  inlineImageLeft?: string | undefined;
6829
+
6830
  inlineImagePadding?: number | undefined;
6831
+
6832
  numberOfLines?: number | undefined;
6833
+
6834
  returnKeyLabel?: string | undefined;
6835
+
6836
+ rows?: number | undefined;
6837
+
6838
+ showSoftInputOnFocus?: boolean | undefined;
6839
+
6840
+ textBreakStrategy?: ('simple' | 'highQuality' | 'balanced') | undefined;
6841
+
6842
  underlineColorAndroid?: ColorValue | undefined;
6843
+ }>;
6844
+
6845
+ declare type TextInputAndroidProps_2 = Readonly<{
6846
+ cursorColor?: ColorValue | undefined;
6847
+
6848
+ selectionHandleColor?: ColorValue | undefined;
6849
+
6850
+ disableFullscreenUI?: boolean | undefined;
6851
+
6852
+ importantForAutofill?:
6853
+ | ('auto' | 'no' | 'noExcludeDescendants' | 'yes' | 'yesExcludeDescendants')
6854
+ | undefined;
6855
+
6856
+ inlineImageLeft?: string | undefined;
6857
+
6858
+ inlineImagePadding?: number | undefined;
6859
+
6860
+ numberOfLines?: number | undefined;
6861
+
6862
+ returnKeyLabel?: string | undefined;
6863
+
6864
+ rows?: number | undefined;
6865
+
6866
  showSoftInputOnFocus?: boolean | undefined;
6867
+
6868
+ textBreakStrategy?: ('simple' | 'highQuality' | 'balanced') | undefined;
6869
+
6870
+ underlineColorAndroid?: ColorValue | undefined;
6871
+ }>;
6872
+
6873
+ declare type TextInputBaseProps = Readonly<{
6874
+ autoCapitalize?: AutoCapitalize | undefined;
6875
+
6876
+ autoComplete?:
6877
+ | (
6878
+ | 'additional-name'
6879
+ | 'address-line1'
6880
+ | 'address-line2'
6881
+ | 'birthdate-day'
6882
+ | 'birthdate-full'
6883
+ | 'birthdate-month'
6884
+ | 'birthdate-year'
6885
+ | 'cc-csc'
6886
+ | 'cc-exp'
6887
+ | 'cc-exp-day'
6888
+ | 'cc-exp-month'
6889
+ | 'cc-exp-year'
6890
+ | 'cc-number'
6891
+ | 'cc-name'
6892
+ | 'cc-given-name'
6893
+ | 'cc-middle-name'
6894
+ | 'cc-family-name'
6895
+ | 'cc-type'
6896
+ | 'country'
6897
+ | 'current-password'
6898
+ | 'email'
6899
+ | 'family-name'
6900
+ | 'gender'
6901
+ | 'given-name'
6902
+ | 'honorific-prefix'
6903
+ | 'honorific-suffix'
6904
+ | 'name'
6905
+ | 'name-family'
6906
+ | 'name-given'
6907
+ | 'name-middle'
6908
+ | 'name-middle-initial'
6909
+ | 'name-prefix'
6910
+ | 'name-suffix'
6911
+ | 'new-password'
6912
+ | 'nickname'
6913
+ | 'one-time-code'
6914
+ | 'organization'
6915
+ | 'organization-title'
6916
+ | 'password'
6917
+ | 'password-new'
6918
+ | 'postal-address'
6919
+ | 'postal-address-country'
6920
+ | 'postal-address-extended'
6921
+ | 'postal-address-extended-postal-code'
6922
+ | 'postal-address-locality'
6923
+ | 'postal-address-region'
6924
+ | 'postal-code'
6925
+ | 'street-address'
6926
+ | 'sms-otp'
6927
+ | 'tel'
6928
+ | 'tel-country-code'
6929
+ | 'tel-national'
6930
+ | 'tel-device'
6931
+ | 'url'
6932
+ | 'username'
6933
+ | 'username-new'
6934
+ | 'off'
6935
+ )
6936
+ | undefined;
6937
+
6938
+ autoCorrect?: boolean | undefined;
6939
+
6940
+ autoFocus?: boolean | undefined;
6941
+
6942
+ allowFontScaling?: boolean | undefined;
6943
+
6944
+ caretHidden?: boolean | undefined;
6945
+ contextMenuHidden?: boolean | undefined;
6946
+
6947
+ defaultValue?: string | undefined;
6948
+
6949
+ editable?: boolean | undefined;
6950
+ forwardedRef?: React.Ref<TextInputInstance> | undefined;
6951
+
6952
+ enterKeyHint?: EnterKeyHintTypeOptions | undefined;
6953
+
6954
+ inputMode?: InputModeOptions | undefined;
6955
+
6956
+ keyboardType?: KeyboardTypeOptions | undefined;
6957
+
6958
+ maxFontSizeMultiplier?: number | undefined;
6959
+
6960
+ maxLength?: number | undefined;
6961
+
6962
+ multiline?: boolean | undefined;
6963
+
6964
+ onBlur?: ((e: TextInputBlurEvent) => unknown) | undefined;
6965
+
6966
+ onChange?: ((e: TextInputChangeEvent) => unknown) | undefined;
6967
+
6968
+ onChangeText?: ((text: string) => unknown) | undefined;
6969
+
6970
+ onContentSizeChange?:
6971
+ | ((e: TextInputContentSizeChangeEvent) => unknown)
6972
+ | undefined;
6973
+
6974
+ onEndEditing?: ((e: TextInputEndEditingEvent) => unknown) | undefined;
6975
+
6976
+ onFocus?: ((e: TextInputFocusEvent) => unknown) | undefined;
6977
+
6978
+ onKeyPress?: ((e: TextInputKeyPressEvent) => unknown) | undefined;
6979
+
6980
+ onPress?: ((event: GestureResponderEvent) => unknown) | undefined;
6981
+
6982
+ onPressIn?: ((event: GestureResponderEvent) => unknown) | undefined;
6983
+
6984
+ onPressOut?: ((event: GestureResponderEvent) => unknown) | undefined;
6985
+
6986
+ onSelectionChange?:
6987
+ | ((e: TextInputSelectionChangeEvent) => unknown)
6988
+ | undefined;
6989
+
6990
+ onSubmitEditing?: ((e: TextInputSubmitEditingEvent) => unknown) | undefined;
6991
+
6992
+ onScroll?: ((e: ScrollEvent) => unknown) | undefined;
6993
+
6994
+ placeholder?: string | undefined;
6995
+
6996
+ placeholderTextColor?: ColorValue | undefined;
6997
+
6998
+ readOnly?: boolean | undefined;
6999
+
7000
+ returnKeyType?: ReturnKeyTypeOptions | undefined;
7001
+
7002
+ secureTextEntry?: boolean | undefined;
7003
+
7004
+ selection?:
7005
+ | Readonly<{
7006
+ start: number;
7007
+ end?: number | undefined;
7008
+ }>
7009
+ | undefined;
7010
+
7011
+ selectionColor?: ColorValue | undefined;
7012
+
7013
+ selectionHandleColor?: ColorValue | undefined;
7014
+
7015
+ selectTextOnFocus?: boolean | undefined;
7016
+
7017
+ blurOnSubmit?: boolean | undefined;
7018
+
7019
+ submitBehavior?: SubmitBehavior | undefined;
7020
+
7021
+ style?: TextStyleProp | undefined;
7022
+
7023
+ value?: string | undefined;
7024
+ }>;
7025
+
7026
+ declare type TextInputBlurEvent = NativeSyntheticEvent<TextInputFocusEventData>;
7027
+
7028
+ declare type TextInputBlurEvent_2 =
7029
+ NativeSyntheticEvent<TextInputFocusEventData_2>;
7030
+
7031
  export declare type TextInputChangeEvent =
7032
  NativeSyntheticEvent<TextInputChangeEventData>;
7033
+
7034
+ declare type TextInputChangeEvent_2 =
7035
+ NativeSyntheticEvent<TextInputChangeEventData_2>;
7036
+
7037
+ declare type TextInputChangeEventData = Readonly<{
7038
  eventCount: number;
7039
+ target: number;
7040
  text: string;
7041
+ }>;
7042
+
7043
+ declare type TextInputChangeEventData_2 = Readonly<{
7044
+ eventCount: number;
7045
+ target: number;
7046
+ text: string;
7047
+ }>;
7048
+
7049
+ declare type TextInputComponentStatics = Readonly<{
7050
+ State: Readonly<{
7051
+ currentlyFocusedInput: () => HostInstance | undefined;
7052
+ currentlyFocusedField: () => number | undefined;
7053
+ focusTextInput: (textField: HostInstance | undefined) => void;
7054
+ blurTextInput: (textField: HostInstance | undefined) => void;
7055
+ }>;
7056
+ }>;
7057
+
7058
  export declare type TextInputContentSizeChangeEvent =
7059
  NativeSyntheticEvent<TextInputContentSizeChangeEventData>;
7060
+
7061
+ declare type TextInputContentSizeChangeEvent_2 =
7062
+ NativeSyntheticEvent<TextInputContentSizeChangeEventData_2>;
7063
+
7064
+ declare type TextInputContentSizeChangeEventData = Readonly<{
7065
+ target: number;
7066
+ contentSize: Readonly<{
7067
+ width: number;
7068
+ height: number;
7069
+ }>;
7070
+ }>;
7071
+
7072
+ declare type TextInputContentSizeChangeEventData_2 = Readonly<{
7073
+ target: number;
7074
+ contentSize: Readonly<{
7075
+ width: number;
7076
+ height: number;
7077
+ }>;
7078
+ }>;
7079
+
7080
  export declare type TextInputEndEditingEvent =
7081
  NativeSyntheticEvent<TextInputEndEditingEventData>;
7082
+
7083
+ declare type TextInputEndEditingEvent_2 =
7084
+ NativeSyntheticEvent<TextInputEndEditingEventData_2>;
7085
+
7086
+ declare type TextInputEndEditingEventData = Readonly<
7087
+ Omit<
7088
+ TargetEvent,
7089
+ keyof {
7090
+ eventCount: number;
7091
+ text: string;
7092
+ }
7093
+ > & {
7094
+ eventCount: number;
7095
+ text: string;
7096
+ }
7097
+ >;
7098
+
7099
+ declare type TextInputEndEditingEventData_2 = Readonly<
7100
+ Omit<
7101
+ TargetEvent_2,
7102
+ keyof {
7103
+ eventCount: number;
7104
+ text: string;
7105
+ }
7106
+ > & {
7107
+ eventCount: number;
7108
+ text: string;
7109
+ }
7110
+ >;
7111
+
7112
  export declare type TextInputFocusEvent =
7113
  NativeSyntheticEvent<TextInputFocusEventData>;
7114
+
7115
+ declare type TextInputFocusEvent_2 =
7116
+ NativeSyntheticEvent<TextInputFocusEventData_2>;
7117
+
7118
+ declare type TextInputFocusEventData = TargetEvent;
7119
+
7120
+ declare type TextInputFocusEventData_2 = TargetEvent_2;
7121
+
7122
+ declare interface TextInputInstance extends HostInstance {
7123
+ readonly clear: () => void;
7124
+ readonly isFocused: () => boolean;
7125
+ readonly getNativeRef: () => HostInstance | undefined;
7126
+ readonly setSelection: (start: number, end: number) => void;
7127
  }
7128
+
7129
+ export declare type TextInputIOSProps = Readonly<{
 
7130
  disableKeyboardShortcuts?: boolean | undefined;
7131
+
7132
  clearButtonMode?:
 
 
7133
+ | ('never' | 'while-editing' | 'unless-editing' | 'always')
 
7134
  | undefined;
7135
+
7136
  clearTextOnFocus?: boolean | undefined;
7137
+
7138
+ dataDetectorTypes?:
7139
+ | (DataDetectorTypesType | undefined)
7140
+ | ReadonlyArray<DataDetectorTypesType>;
7141
+
7142
  enablesReturnKeyAutomatically?: boolean | undefined;
7143
+
7144
+ inputAccessoryViewID?: string | undefined;
7145
+
7146
+ inputAccessoryViewButtonLabel?: string | undefined;
7147
+
7148
+ keyboardAppearance?: ('default' | 'light' | 'dark') | undefined;
7149
+
7150
+ passwordRules?: PasswordRules | undefined;
7151
+ rejectResponderTermination?: boolean | undefined;
7152
+
7153
+ scrollEnabled?: boolean | undefined;
7154
+
7155
  spellCheck?: boolean | undefined;
7156
+
7157
+ textContentType?: TextContentType | undefined;
7158
+
7159
+ lineBreakStrategyIOS?:
 
 
 
 
 
 
 
 
7160
+ | ('none' | 'standard' | 'hangul-word' | 'push-out')
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
7161
  | undefined;
7162
+
7163
+ lineBreakModeIOS?:
7164
+ | ('wordWrapping' | 'char' | 'clip' | 'head' | 'middle' | 'tail')
7165
+ | undefined;
7166
+
7167
+ smartInsertDelete?: boolean | undefined;
7168
+ }>;
7169
+
7170
+ declare type TextInputIOSProps_2 = Readonly<{
7171
+ disableKeyboardShortcuts?: boolean | undefined;
7172
+
7173
+ clearButtonMode?:
7174
+ | ('never' | 'while-editing' | 'unless-editing' | 'always')
7175
+ | undefined;
7176
+
7177
+ clearTextOnFocus?: boolean | undefined;
7178
+
7179
+ dataDetectorTypes?:
7180
+ | (DataDetectorTypesType_2 | undefined)
7181
+ | ReadonlyArray<DataDetectorTypesType_2>;
7182
+
7183
+ enablesReturnKeyAutomatically?: boolean | undefined;
7184
+
7185
+ inputAccessoryViewID?: string | undefined;
7186
+
7187
+ inputAccessoryViewButtonLabel?: string | undefined;
7188
+
7189
+ keyboardAppearance?: ('default' | 'light' | 'dark') | undefined;
7190
+
7191
+ passwordRules?: PasswordRules_2 | undefined;
7192
+ rejectResponderTermination?: boolean | undefined;
7193
+
7194
  scrollEnabled?: boolean | undefined;
7195
+
7196
+ spellCheck?: boolean | undefined;
7197
+
7198
+ textContentType?: TextContentType_2 | undefined;
7199
+
7200
  lineBreakStrategyIOS?:
 
 
7201
+ | ('none' | 'standard' | 'hangul-word' | 'push-out')
 
7202
  | undefined;
7203
+
7204
  lineBreakModeIOS?:
7205
+ | ('wordWrapping' | 'char' | 'clip' | 'head' | 'middle' | 'tail')
 
 
 
 
 
7206
  | undefined;
7207
+
7208
  smartInsertDelete?: boolean | undefined;
7209
+ }>;
7210
+
7211
  export declare type TextInputKeyPressEvent =
7212
  NativeSyntheticEvent<TextInputKeyPressEventData>;
7213
+
7214
+ declare type TextInputKeyPressEvent_2 =
7215
+ NativeSyntheticEvent<TextInputKeyPressEventData_2>;
7216
+
7217
+ declare type TextInputKeyPressEventData = Readonly<
7218
+ Omit<
7219
+ TargetEvent,
7220
+ keyof {
7221
+ key: string;
7222
+ target?: number | undefined;
7223
+ eventCount?: number | undefined;
7224
+ }
7225
+ > & {
7226
+ key: string;
7227
+ target?: number | undefined;
7228
+ eventCount?: number | undefined;
7229
+ }
7230
+ >;
7231
+
7232
+ declare type TextInputKeyPressEventData_2 = Readonly<
7233
+ Omit<
7234
+ TargetEvent_2,
7235
+ keyof {
7236
+ key: string;
7237
+ target?: number | undefined;
7238
+ eventCount: number;
7239
+ }
7240
+ > & {
7241
+ key: string;
7242
+ target?: number | undefined;
7243
+ eventCount: number;
7244
+ }
7245
+ >;
7246
+
7247
+ export declare type TextInputProps = Readonly<
7248
+ Omit<
7249
+ Pick<
7250
+ ViewProps,
7251
+ Exclude<
7252
+ keyof ViewProps,
7253
+ keyof Readonly<{
7254
+ style: ViewStyleProp | undefined;
7255
+ }>
7256
+ >
7257
+ >,
7258
+ keyof (TextInputIOSProps | TextInputAndroidProps | TextInputBaseProps | {})
7259
+ > &
7260
+ Omit<
7261
+ TextInputIOSProps,
7262
+ keyof (TextInputAndroidProps | TextInputBaseProps | {})
7263
+ > &
7264
+ Omit<TextInputAndroidProps, keyof (TextInputBaseProps | {})> &
7265
+ Omit<TextInputBaseProps, keyof {}> & {}
7266
+ >;
7267
+
7268
+ declare type TextInputProps_2 = Readonly<
7269
+ Omit<
7270
+ Pick<
7271
+ ViewProps,
7272
+ Exclude<
7273
+ keyof ViewProps,
7274
+ keyof Readonly<{
7275
+ style: ViewStyleProp | undefined;
7276
+ }>
7277
+ >
7278
+ >,
7279
+ keyof (
7280
+ | TextInputIOSProps_2
7281
+ | TextInputAndroidProps_2
7282
+ | {
7283
+ autoCapitalize?: AutoCapitalize_2 | undefined;
7284
+
7285
+ autoComplete?:
7286
+ | (
7287
+ | 'additional-name'
7288
+ | 'address-line1'
7289
+ | 'address-line2'
7290
+ | 'birthdate-day'
7291
+ | 'birthdate-full'
7292
+ | 'birthdate-month'
7293
+ | 'birthdate-year'
7294
+ | 'cc-csc'
7295
+ | 'cc-exp'
7296
+ | 'cc-exp-day'
7297
+ | 'cc-exp-month'
7298
+ | 'cc-exp-year'
7299
+ | 'cc-number'
7300
+ | 'cc-name'
7301
+ | 'cc-given-name'
7302
+ | 'cc-middle-name'
7303
+ | 'cc-family-name'
7304
+ | 'cc-type'
7305
+ | 'country'
7306
+ | 'current-password'
7307
+ | 'email'
7308
+ | 'family-name'
7309
+ | 'gender'
7310
+ | 'given-name'
7311
+ | 'honorific-prefix'
7312
+ | 'honorific-suffix'
7313
+ | 'name'
7314
+ | 'name-family'
7315
+ | 'name-given'
7316
+ | 'name-middle'
7317
+ | 'name-middle-initial'
7318
+ | 'name-prefix'
7319
+ | 'name-suffix'
7320
+ | 'new-password'
7321
+ | 'nickname'
7322
+ | 'one-time-code'
7323
+ | 'organization'
7324
+ | 'organization-title'
7325
+ | 'password'
7326
+ | 'password-new'
7327
+ | 'postal-address'
7328
+ | 'postal-address-country'
7329
+ | 'postal-address-extended'
7330
+ | 'postal-address-extended-postal-code'
7331
+ | 'postal-address-locality'
7332
+ | 'postal-address-region'
7333
+ | 'postal-code'
7334
+ | 'street-address'
7335
+ | 'sms-otp'
7336
+ | 'tel'
7337
+ | 'tel-country-code'
7338
+ | 'tel-national'
7339
+ | 'tel-device'
7340
+ | 'url'
7341
+ | 'username'
7342
+ | 'username-new'
7343
+ | 'off'
7344
+ )
7345
+ | undefined;
7346
+
7347
+ autoCorrect?: boolean | undefined;
7348
+
7349
+ autoFocus?: boolean | undefined;
7350
+
7351
+ allowFontScaling?: boolean | undefined;
7352
+
7353
+ caretHidden?: boolean | undefined;
7354
+ contextMenuHidden?: boolean | undefined;
7355
+
7356
+ defaultValue?: string | undefined;
7357
+
7358
+ editable?: boolean | undefined;
7359
+ forwardedRef?: React.Ref<TextInputInstance> | undefined;
7360
+
7361
+ enterKeyHint?: EnterKeyHintTypeOptions_2 | undefined;
7362
+
7363
+ inputMode?: InputModeOptions_2 | undefined;
7364
+
7365
+ keyboardType?: KeyboardTypeOptions_2 | undefined;
7366
+
7367
+ maxFontSizeMultiplier?: number | undefined;
7368
+
7369
+ maxLength?: number | undefined;
7370
+
7371
+ multiline?: boolean | undefined;
7372
+
7373
+ onBlur?: ((e: TextInputBlurEvent_2) => unknown) | undefined;
7374
+
7375
+ onChange?: ((e: TextInputChangeEvent_2) => unknown) | undefined;
7376
+
7377
+ unstable_onChangeSync?:
7378
+ | ((e: TextInputChangeEvent_2) => unknown)
7379
+ | undefined;
7380
+
7381
+ onChangeText?: ((text: string) => unknown) | undefined;
7382
+
7383
+ unstable_onChangeTextSync?: ((text: string) => unknown) | undefined;
7384
+
7385
+ onContentSizeChange?:
7386
+ | ((e: TextInputContentSizeChangeEvent_2) => unknown)
7387
+ | undefined;
7388
+
7389
+ onEndEditing?:
7390
+ | ((e: TextInputEndEditingEvent_2) => unknown)
7391
+ | undefined;
7392
+
7393
+ onFocus?: ((e: TextInputFocusEvent_2) => unknown) | undefined;
7394
+
7395
+ onKeyPress?: ((e: TextInputKeyPressEvent_2) => unknown) | undefined;
7396
+
7397
+ unstable_onKeyPressSync?:
7398
+ | ((e: TextInputKeyPressEvent_2) => unknown)
7399
+ | undefined;
7400
+
7401
+ onPress?: ((event: GestureResponderEvent) => unknown) | undefined;
7402
+
7403
+ onPressIn?: ((event: GestureResponderEvent) => unknown) | undefined;
7404
+
7405
+ onPressOut?: ((event: GestureResponderEvent) => unknown) | undefined;
7406
+
7407
+ onSelectionChange?:
7408
+ | ((e: TextInputSelectionChangeEvent_2) => unknown)
7409
+ | undefined;
7410
+
7411
+ onSubmitEditing?:
7412
+ | ((e: TextInputSubmitEditingEvent_2) => unknown)
7413
+ | undefined;
7414
+
7415
+ onScroll?: ((e: ScrollEvent) => unknown) | undefined;
7416
+
7417
+ placeholder?: string | undefined;
7418
+
7419
+ placeholderTextColor?: ColorValue | undefined;
7420
+
7421
+ readOnly?: boolean | undefined;
7422
+
7423
+ returnKeyType?: ReturnKeyTypeOptions_2 | undefined;
7424
+
7425
+ secureTextEntry?: boolean | undefined;
7426
+
7427
+ selection?:
7428
+ | Readonly<{
7429
+ start: number;
7430
+ end?: number | undefined;
7431
+ }>
7432
+ | undefined;
7433
+
7434
+ selectionColor?: ColorValue | undefined;
7435
+
7436
+ selectTextOnFocus?: boolean | undefined;
7437
+
7438
+ blurOnSubmit?: boolean | undefined;
7439
+
7440
+ submitBehavior?: SubmitBehavior_2 | undefined;
7441
+
7442
+ style?: TextStyleProp | undefined;
7443
+
7444
+ value?: string | undefined;
7445
+ }
7446
+ )
7447
+ > &
7448
+ Omit<
7449
+ TextInputIOSProps_2,
7450
+ keyof (
7451
+ | TextInputAndroidProps_2
7452
+ | {
7453
+ autoCapitalize?: AutoCapitalize_2 | undefined;
7454
+
7455
+ autoComplete?:
7456
+ | (
7457
+ | 'additional-name'
7458
+ | 'address-line1'
7459
+ | 'address-line2'
7460
+ | 'birthdate-day'
7461
+ | 'birthdate-full'
7462
+ | 'birthdate-month'
7463
+ | 'birthdate-year'
7464
+ | 'cc-csc'
7465
+ | 'cc-exp'
7466
+ | 'cc-exp-day'
7467
+ | 'cc-exp-month'
7468
+ | 'cc-exp-year'
7469
+ | 'cc-number'
7470
+ | 'cc-name'
7471
+ | 'cc-given-name'
7472
+ | 'cc-middle-name'
7473
+ | 'cc-family-name'
7474
+ | 'cc-type'
7475
+ | 'country'
7476
+ | 'current-password'
7477
+ | 'email'
7478
+ | 'family-name'
7479
+ | 'gender'
7480
+ | 'given-name'
7481
+ | 'honorific-prefix'
7482
+ | 'honorific-suffix'
7483
+ | 'name'
7484
+ | 'name-family'
7485
+ | 'name-given'
7486
+ | 'name-middle'
7487
+ | 'name-middle-initial'
7488
+ | 'name-prefix'
7489
+ | 'name-suffix'
7490
+ | 'new-password'
7491
+ | 'nickname'
7492
+ | 'one-time-code'
7493
+ | 'organization'
7494
+ | 'organization-title'
7495
+ | 'password'
7496
+ | 'password-new'
7497
+ | 'postal-address'
7498
+ | 'postal-address-country'
7499
+ | 'postal-address-extended'
7500
+ | 'postal-address-extended-postal-code'
7501
+ | 'postal-address-locality'
7502
+ | 'postal-address-region'
7503
+ | 'postal-code'
7504
+ | 'street-address'
7505
+ | 'sms-otp'
7506
+ | 'tel'
7507
+ | 'tel-country-code'
7508
+ | 'tel-national'
7509
+ | 'tel-device'
7510
+ | 'url'
7511
+ | 'username'
7512
+ | 'username-new'
7513
+ | 'off'
7514
+ )
7515
+ | undefined;
7516
+
7517
+ autoCorrect?: boolean | undefined;
7518
+
7519
+ autoFocus?: boolean | undefined;
7520
+
7521
+ allowFontScaling?: boolean | undefined;
7522
+
7523
+ caretHidden?: boolean | undefined;
7524
+ contextMenuHidden?: boolean | undefined;
7525
+
7526
+ defaultValue?: string | undefined;
7527
+
7528
+ editable?: boolean | undefined;
7529
+ forwardedRef?: React.Ref<TextInputInstance> | undefined;
7530
+
7531
+ enterKeyHint?: EnterKeyHintTypeOptions_2 | undefined;
7532
+
7533
+ inputMode?: InputModeOptions_2 | undefined;
7534
+
7535
+ keyboardType?: KeyboardTypeOptions_2 | undefined;
7536
+
7537
+ maxFontSizeMultiplier?: number | undefined;
7538
+
7539
+ maxLength?: number | undefined;
7540
+
7541
+ multiline?: boolean | undefined;
7542
+
7543
+ onBlur?: ((e: TextInputBlurEvent_2) => unknown) | undefined;
7544
+
7545
+ onChange?: ((e: TextInputChangeEvent_2) => unknown) | undefined;
7546
+
7547
+ unstable_onChangeSync?:
7548
+ | ((e: TextInputChangeEvent_2) => unknown)
7549
+ | undefined;
7550
+
7551
+ onChangeText?: ((text: string) => unknown) | undefined;
7552
+
7553
+ unstable_onChangeTextSync?: ((text: string) => unknown) | undefined;
7554
+
7555
+ onContentSizeChange?:
7556
+ | ((e: TextInputContentSizeChangeEvent_2) => unknown)
7557
+ | undefined;
7558
+
7559
+ onEndEditing?:
7560
+ | ((e: TextInputEndEditingEvent_2) => unknown)
7561
+ | undefined;
7562
+
7563
+ onFocus?: ((e: TextInputFocusEvent_2) => unknown) | undefined;
7564
+
7565
+ onKeyPress?: ((e: TextInputKeyPressEvent_2) => unknown) | undefined;
7566
+
7567
+ unstable_onKeyPressSync?:
7568
+ | ((e: TextInputKeyPressEvent_2) => unknown)
7569
+ | undefined;
7570
+
7571
+ onPress?: ((event: GestureResponderEvent) => unknown) | undefined;
7572
+
7573
+ onPressIn?: ((event: GestureResponderEvent) => unknown) | undefined;
7574
+
7575
+ onPressOut?:
7576
+ | ((event: GestureResponderEvent) => unknown)
7577
+ | undefined;
7578
+
7579
+ onSelectionChange?:
7580
+ | ((e: TextInputSelectionChangeEvent_2) => unknown)
7581
+ | undefined;
7582
+
7583
+ onSubmitEditing?:
7584
+ | ((e: TextInputSubmitEditingEvent_2) => unknown)
7585
+ | undefined;
7586
+
7587
+ onScroll?: ((e: ScrollEvent) => unknown) | undefined;
7588
+
7589
+ placeholder?: string | undefined;
7590
+
7591
+ placeholderTextColor?: ColorValue | undefined;
7592
+
7593
+ readOnly?: boolean | undefined;
7594
+
7595
+ returnKeyType?: ReturnKeyTypeOptions_2 | undefined;
7596
+
7597
+ secureTextEntry?: boolean | undefined;
7598
+
7599
+ selection?:
7600
+ | Readonly<{
7601
+ start: number;
7602
+ end?: number | undefined;
7603
+ }>
7604
+ | undefined;
7605
+
7606
+ selectionColor?: ColorValue | undefined;
7607
+
7608
+ selectTextOnFocus?: boolean | undefined;
7609
+
7610
+ blurOnSubmit?: boolean | undefined;
7611
+
7612
+ submitBehavior?: SubmitBehavior_2 | undefined;
7613
+
7614
+ style?: TextStyleProp | undefined;
7615
+
7616
+ value?: string | undefined;
7617
+ }
7618
+ )
7619
+ > &
7620
+ Omit<
7621
+ TextInputAndroidProps_2,
7622
+ keyof {
7623
+ autoCapitalize?: AutoCapitalize_2 | undefined;
7624
+
7625
+ autoComplete?:
7626
+ | (
7627
+ | 'additional-name'
7628
+ | 'address-line1'
7629
+ | 'address-line2'
7630
+ | 'birthdate-day'
7631
+ | 'birthdate-full'
7632
+ | 'birthdate-month'
7633
+ | 'birthdate-year'
7634
+ | 'cc-csc'
7635
+ | 'cc-exp'
7636
+ | 'cc-exp-day'
7637
+ | 'cc-exp-month'
7638
+ | 'cc-exp-year'
7639
+ | 'cc-number'
7640
+ | 'cc-name'
7641
+ | 'cc-given-name'
7642
+ | 'cc-middle-name'
7643
+ | 'cc-family-name'
7644
+ | 'cc-type'
7645
+ | 'country'
7646
+ | 'current-password'
7647
+ | 'email'
7648
+ | 'family-name'
7649
+ | 'gender'
7650
+ | 'given-name'
7651
+ | 'honorific-prefix'
7652
+ | 'honorific-suffix'
7653
+ | 'name'
7654
+ | 'name-family'
7655
+ | 'name-given'
7656
+ | 'name-middle'
7657
+ | 'name-middle-initial'
7658
+ | 'name-prefix'
7659
+ | 'name-suffix'
7660
+ | 'new-password'
7661
+ | 'nickname'
7662
+ | 'one-time-code'
7663
+ | 'organization'
7664
+ | 'organization-title'
7665
+ | 'password'
7666
+ | 'password-new'
7667
+ | 'postal-address'
7668
+ | 'postal-address-country'
7669
+ | 'postal-address-extended'
7670
+ | 'postal-address-extended-postal-code'
7671
+ | 'postal-address-locality'
7672
+ | 'postal-address-region'
7673
+ | 'postal-code'
7674
+ | 'street-address'
7675
+ | 'sms-otp'
7676
+ | 'tel'
7677
+ | 'tel-country-code'
7678
+ | 'tel-national'
7679
+ | 'tel-device'
7680
+ | 'url'
7681
+ | 'username'
7682
+ | 'username-new'
7683
+ | 'off'
7684
+ )
7685
+ | undefined;
7686
+
7687
+ autoCorrect?: boolean | undefined;
7688
+
7689
+ autoFocus?: boolean | undefined;
7690
+
7691
+ allowFontScaling?: boolean | undefined;
7692
+
7693
+ caretHidden?: boolean | undefined;
7694
+ contextMenuHidden?: boolean | undefined;
7695
+
7696
+ defaultValue?: string | undefined;
7697
+
7698
+ editable?: boolean | undefined;
7699
+ forwardedRef?: React.Ref<TextInputInstance> | undefined;
7700
+
7701
+ enterKeyHint?: EnterKeyHintTypeOptions_2 | undefined;
7702
+
7703
+ inputMode?: InputModeOptions_2 | undefined;
7704
+
7705
+ keyboardType?: KeyboardTypeOptions_2 | undefined;
7706
+
7707
+ maxFontSizeMultiplier?: number | undefined;
7708
+
7709
+ maxLength?: number | undefined;
7710
+
7711
+ multiline?: boolean | undefined;
7712
+
7713
+ onBlur?: ((e: TextInputBlurEvent_2) => unknown) | undefined;
7714
+
7715
+ onChange?: ((e: TextInputChangeEvent_2) => unknown) | undefined;
7716
+
7717
+ unstable_onChangeSync?:
7718
+ | ((e: TextInputChangeEvent_2) => unknown)
7719
+ | undefined;
7720
+
7721
+ onChangeText?: ((text: string) => unknown) | undefined;
7722
+
7723
+ unstable_onChangeTextSync?: ((text: string) => unknown) | undefined;
7724
+
7725
+ onContentSizeChange?:
7726
+ | ((e: TextInputContentSizeChangeEvent_2) => unknown)
7727
+ | undefined;
7728
+
7729
+ onEndEditing?: ((e: TextInputEndEditingEvent_2) => unknown) | undefined;
7730
+
7731
+ onFocus?: ((e: TextInputFocusEvent_2) => unknown) | undefined;
7732
+
7733
+ onKeyPress?: ((e: TextInputKeyPressEvent_2) => unknown) | undefined;
7734
+
7735
+ unstable_onKeyPressSync?:
7736
+ | ((e: TextInputKeyPressEvent_2) => unknown)
7737
+ | undefined;
7738
+
7739
+ onPress?: ((event: GestureResponderEvent) => unknown) | undefined;
7740
+
7741
+ onPressIn?: ((event: GestureResponderEvent) => unknown) | undefined;
7742
+
7743
+ onPressOut?: ((event: GestureResponderEvent) => unknown) | undefined;
7744
+
7745
+ onSelectionChange?:
7746
+ | ((e: TextInputSelectionChangeEvent_2) => unknown)
7747
+ | undefined;
7748
+
7749
+ onSubmitEditing?:
7750
+ | ((e: TextInputSubmitEditingEvent_2) => unknown)
7751
+ | undefined;
7752
+
7753
+ onScroll?: ((e: ScrollEvent) => unknown) | undefined;
7754
+
7755
+ placeholder?: string | undefined;
7756
+
7757
+ placeholderTextColor?: ColorValue | undefined;
7758
+
7759
+ readOnly?: boolean | undefined;
7760
+
7761
+ returnKeyType?: ReturnKeyTypeOptions_2 | undefined;
7762
+
7763
+ secureTextEntry?: boolean | undefined;
7764
+
7765
+ selection?:
7766
+ | Readonly<{
7767
+ start: number;
7768
+ end?: number | undefined;
7769
+ }>
7770
+ | undefined;
7771
+
7772
+ selectionColor?: ColorValue | undefined;
7773
+
7774
+ selectTextOnFocus?: boolean | undefined;
7775
+
7776
+ blurOnSubmit?: boolean | undefined;
7777
+
7778
+ submitBehavior?: SubmitBehavior_2 | undefined;
7779
+
7780
+ style?: TextStyleProp | undefined;
7781
+
7782
+ value?: string | undefined;
7783
+ }
7784
+ > & {
7785
+ autoCapitalize?: AutoCapitalize_2 | undefined;
7786
+
7787
+ autoComplete?:
7788
+ | (
7789
+ | 'additional-name'
7790
+ | 'address-line1'
7791
+ | 'address-line2'
7792
+ | 'birthdate-day'
7793
+ | 'birthdate-full'
7794
+ | 'birthdate-month'
7795
+ | 'birthdate-year'
7796
+ | 'cc-csc'
7797
+ | 'cc-exp'
7798
+ | 'cc-exp-day'
7799
+ | 'cc-exp-month'
7800
+ | 'cc-exp-year'
7801
+ | 'cc-number'
7802
+ | 'cc-name'
7803
+ | 'cc-given-name'
7804
+ | 'cc-middle-name'
7805
+ | 'cc-family-name'
7806
+ | 'cc-type'
7807
+ | 'country'
7808
+ | 'current-password'
7809
+ | 'email'
7810
+ | 'family-name'
7811
+ | 'gender'
7812
+ | 'given-name'
7813
+ | 'honorific-prefix'
7814
+ | 'honorific-suffix'
7815
+ | 'name'
7816
+ | 'name-family'
7817
+ | 'name-given'
7818
+ | 'name-middle'
7819
+ | 'name-middle-initial'
7820
+ | 'name-prefix'
7821
+ | 'name-suffix'
7822
+ | 'new-password'
7823
+ | 'nickname'
7824
+ | 'one-time-code'
7825
+ | 'organization'
7826
+ | 'organization-title'
7827
+ | 'password'
7828
+ | 'password-new'
7829
+ | 'postal-address'
7830
+ | 'postal-address-country'
7831
+ | 'postal-address-extended'
7832
+ | 'postal-address-extended-postal-code'
7833
+ | 'postal-address-locality'
7834
+ | 'postal-address-region'
7835
+ | 'postal-code'
7836
+ | 'street-address'
7837
+ | 'sms-otp'
7838
+ | 'tel'
7839
+ | 'tel-country-code'
7840
+ | 'tel-national'
7841
+ | 'tel-device'
7842
+ | 'url'
7843
+ | 'username'
7844
+ | 'username-new'
7845
+ | 'off'
7846
+ )
7847
+ | undefined;
7848
+
7849
+ autoCorrect?: boolean | undefined;
7850
+
7851
+ autoFocus?: boolean | undefined;
7852
+
7853
+ allowFontScaling?: boolean | undefined;
7854
+
7855
+ caretHidden?: boolean | undefined;
7856
+ contextMenuHidden?: boolean | undefined;
7857
+
7858
+ defaultValue?: string | undefined;
7859
+
7860
+ editable?: boolean | undefined;
7861
+ forwardedRef?: React.Ref<TextInputInstance> | undefined;
7862
+
7863
+ enterKeyHint?: EnterKeyHintTypeOptions_2 | undefined;
7864
+
7865
+ inputMode?: InputModeOptions_2 | undefined;
7866
+
7867
+ keyboardType?: KeyboardTypeOptions_2 | undefined;
7868
+
7869
+ maxFontSizeMultiplier?: number | undefined;
7870
+
7871
+ maxLength?: number | undefined;
7872
+
7873
+ multiline?: boolean | undefined;
7874
+
7875
+ onBlur?: ((e: TextInputBlurEvent_2) => unknown) | undefined;
7876
+
7877
+ onChange?: ((e: TextInputChangeEvent_2) => unknown) | undefined;
7878
+
7879
+ unstable_onChangeSync?:
7880
+ | ((e: TextInputChangeEvent_2) => unknown)
7881
+ | undefined;
7882
+
7883
+ onChangeText?: ((text: string) => unknown) | undefined;
7884
+
7885
+ unstable_onChangeTextSync?: ((text: string) => unknown) | undefined;
7886
+
7887
+ onContentSizeChange?:
7888
+ | ((e: TextInputContentSizeChangeEvent_2) => unknown)
7889
+ | undefined;
7890
+
7891
+ onEndEditing?: ((e: TextInputEndEditingEvent_2) => unknown) | undefined;
7892
+
7893
+ onFocus?: ((e: TextInputFocusEvent_2) => unknown) | undefined;
7894
+
7895
+ onKeyPress?: ((e: TextInputKeyPressEvent_2) => unknown) | undefined;
7896
+
7897
+ unstable_onKeyPressSync?:
7898
+ | ((e: TextInputKeyPressEvent_2) => unknown)
7899
+ | undefined;
7900
+
7901
+ onPress?: ((event: GestureResponderEvent) => unknown) | undefined;
7902
+
7903
+ onPressIn?: ((event: GestureResponderEvent) => unknown) | undefined;
7904
+
7905
+ onPressOut?: ((event: GestureResponderEvent) => unknown) | undefined;
7906
+
7907
+ onSelectionChange?:
7908
+ | ((e: TextInputSelectionChangeEvent_2) => unknown)
7909
+ | undefined;
7910
+
7911
+ onSubmitEditing?:
7912
+ | ((e: TextInputSubmitEditingEvent_2) => unknown)
7913
+ | undefined;
7914
+
7915
+ onScroll?: ((e: ScrollEvent) => unknown) | undefined;
7916
+
7917
+ placeholder?: string | undefined;
7918
+
7919
+ placeholderTextColor?: ColorValue | undefined;
7920
+
7921
+ readOnly?: boolean | undefined;
7922
+
7923
+ returnKeyType?: ReturnKeyTypeOptions_2 | undefined;
7924
+
7925
+ secureTextEntry?: boolean | undefined;
7926
+
7927
+ selection?:
7928
+ | Readonly<{
7929
+ start: number;
7930
+ end?: number | undefined;
7931
+ }>
7932
+ | undefined;
7933
+
7934
+ selectionColor?: ColorValue | undefined;
7935
+
7936
+ selectTextOnFocus?: boolean | undefined;
7937
+
7938
+ blurOnSubmit?: boolean | undefined;
7939
+
7940
+ submitBehavior?: SubmitBehavior_2 | undefined;
7941
+
7942
+ style?: TextStyleProp | undefined;
7943
+
7944
+ value?: string | undefined;
7945
+ }
7946
+ >;
7947
+
7948
  export declare type TextInputScrollEvent =
7949
  NativeSyntheticEvent<TextInputScrollEventData>;
7950
+
7951
+ declare type TextInputScrollEventData = {
7952
+ contentOffset: {
7953
+ x: number;
7954
+ y: number;
7955
+ };
7956
+ };
7957
+
7958
  export declare type TextInputSelectionChangeEvent =
7959
  NativeSyntheticEvent<TextInputSelectionChangeEventData>;
7960
+
7961
+ declare type TextInputSelectionChangeEvent_2 =
7962
+ NativeSyntheticEvent<TextInputSelectionChangeEventData_2>;
7963
+
7964
+ declare type TextInputSelectionChangeEventData = Readonly<
7965
+ Omit<
7966
+ TargetEvent,
7967
+ keyof {
7968
+ selection: Selection_2;
 
 
 
7969
+ }
7970
+ > & {
7971
+ selection: Selection_2;
 
 
 
7972
+ }
7973
+ >;
7974
+
7975
+ declare type TextInputSelectionChangeEventData_2 = Readonly<
7976
+ Omit<
7977
+ TargetEvent_2,
7978
+ keyof {
7979
+ selection: Selection_3;
7980
+ }
7981
+ > & {
7982
+ selection: Selection_3;
7983
+ }
7984
+ >;
7985
+
7986
  export declare type TextInputSubmitEditingEvent =
7987
  NativeSyntheticEvent<TextInputSubmitEditingEventData>;
7988
+
7989
+ declare type TextInputSubmitEditingEvent_2 =
7990
+ NativeSyntheticEvent<TextInputSubmitEditingEventData_2>;
7991
+
7992
+ declare type TextInputSubmitEditingEventData = Readonly<
7993
+ Omit<
7994
+ TargetEvent,
7995
+ keyof {
7996
+ eventCount: number;
7997
+ text: string;
7998
+ }
7999
+ > & {
8000
+ eventCount: number;
8001
+ text: string;
8002
+ }
8003
+ >;
8004
+
8005
+ declare type TextInputSubmitEditingEventData_2 = Readonly<
8006
+ Omit<
8007
+ TargetEvent_2,
8008
+ keyof {
8009
+ eventCount: number;
8010
+ text: string;
8011
+ }
8012
+ > & {
8013
+ eventCount: number;
8014
+ text: string;
8015
+ }
8016
+ >;
8017
+
8018
+ declare type TextInputType = InternalTextInput & TextInputComponentStatics;
8019
+
8020
  export declare type TextLayoutEvent = NativeSyntheticEvent<TextLayoutEventData>;
8021
+
8022
+ declare type TextLayoutEventData = Readonly<{
8023
+ lines: Array<TextLayoutLine>;
8024
+ }>;
8025
+
8026
+ declare type TextLayoutLine = Readonly<
8027
+ Omit<
8028
+ LayoutRectangle,
8029
+ keyof {
8030
+ ascender: number;
8031
+ capHeight: number;
8032
+ descender: number;
8033
+ text: string;
8034
+ xHeight: number;
8035
+ }
8036
+ > & {
8037
+ ascender: number;
8038
+ capHeight: number;
8039
+ descender: number;
 
8040
+ text: string;
 
 
8041
+ xHeight: number;
 
8042
+ }
8043
+ >;
8044
+
8045
+ export declare type TextProps = Readonly<
8046
+ Omit<
8047
+ PointerEventProps_2,
8048
+ keyof (TextPropsIOS | TextPropsAndroid | TextBaseProps | {})
8049
+ > &
8050
+ Omit<TextPropsIOS, keyof (TextPropsAndroid | TextBaseProps | {})> &
 
 
 
 
 
 
 
 
 
 
 
8051
+ Omit<TextPropsAndroid, keyof (TextBaseProps | {})> &
 
 
 
 
8052
+ Omit<TextBaseProps, keyof {}> & {}
8053
+ >;
8054
+
 
 
 
 
8055
+ declare type TextPropsAndroid = {
8056
  disabled?: boolean | undefined;
8057
+
8058
  selectionColor?: ColorValue | undefined;
8059
+
8060
  dataDetectorType?:
 
8061
+ | ('phoneNumber' | 'link' | 'email' | 'none' | 'all')
 
 
 
 
8062
  | undefined;
8063
+
8064
+ textBreakStrategy?: ('balanced' | 'highQuality' | 'simple') | undefined;
8065
+
 
8066
  adjustsFontSizeToFit?: boolean | undefined;
8067
+
8068
+ minimumFontScale?: number | undefined;
8069
+ };
8070
+
8071
+ declare type TextPropsIOS = {
8072
+ adjustsFontSizeToFit?: boolean | undefined;
8073
+
8074
  dynamicTypeRamp?:
8075
+ | (
8076
+ | 'caption2'
8077
+ | 'caption1'
8078
+ | 'footnote'
8079
+ | 'subheadline'
8080
+ | 'callout'
8081
+ | 'body'
8082
+ | 'headline'
8083
+ | 'title3'
8084
+ | 'title2'
8085
+ | 'title1'
8086
+ | 'largeTitle'
8087
+ )
8088
  | undefined;
8089
+
8090
  suppressHighlighting?: boolean | undefined;
8091
+
8092
  lineBreakStrategyIOS?:
 
 
8093
+ | ('none' | 'standard' | 'hangul-word' | 'push-out')
 
8094
  | undefined;
8095
+ };
8096
+
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
8097
+ export declare type TextStyle = ____TextStyle_Internal;
8098
+
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
8099
+ declare type TextStyleProp = ____TextStyleProp_Internal;
8100
+
 
 
 
 
8101
  declare type Timespan = {
8102
  startTime: number;
8103
+ endTime?: number;
8104
+ totalTime?: number;
8105
+ startExtras?: Extras;
8106
+ endExtras?: Extras;
8107
  };
8108
+
8109
+ declare const timing: (
8110
+ value: AnimatedValue | AnimatedValueXY | AnimatedColor,
8111
+ config: TimingAnimationConfig
8112
+ ) => CompositeAnimation;
8113
+
8114
+ declare const timing_2: typeof AnimatedImplementation_MODULE_EXPORT.timing;
8115
+
8116
+ declare type timing_2 = typeof timing_2;
8117
+
8118
+ declare type TimingAnimationConfig = Readonly<
8119
+ Omit<
8120
+ AnimationConfig,
8121
+ keyof {
8122
+ toValue:
8123
+ | number
8124
+ | AnimatedValue
8125
+ | Readonly<{
8126
+ x: number;
8127
+ y: number;
8128
+ }>
8129
+ | AnimatedValueXY
8130
+ | RgbaValue
8131
+ | AnimatedColor
8132
+ | AnimatedInterpolation<number>;
8133
+ easing?: (value: number) => number;
 
 
8134
+ duration?: number;
8135
+ delay?: number;
8136
+ }
8137
+ > & {
8138
+ toValue:
8139
+ | number
8140
+ | AnimatedValue
8141
+ | Readonly<{
8142
+ x: number;
8143
+ y: number;
8144
+ }>
8145
+ | AnimatedValueXY
8146
+ | RgbaValue
8147
+ | AnimatedColor
8148
+ | AnimatedInterpolation<number>;
8149
+ easing?: (value: number) => number;
8150
+ duration?: number;
8151
+ delay?: number;
8152
+ }
8153
+ >;
8154
+
8155
+ export declare const ToastAndroid: typeof ToastAndroid_2;
8156
+
8157
+ export declare type ToastAndroid = typeof ToastAndroid;
8158
+
8159
+ declare const ToastAndroid_2: {
8160
  SHORT: number;
8161
  LONG: number;
8162
  TOP: number;
8163
  BOTTOM: number;
8164
  CENTER: number;
 
 
8165
+ show: (message: string, duration: number) => void;
8166
+ showWithGravity: (message: string, duration: number, gravity: number) => void;
 
 
 
 
 
 
8167
+ showWithGravityAndOffset: (
8168
+ message: string,
8169
+ duration: number,
8170
+ gravity: number,
8171
+ xOffset: number,
8172
+ yOffset: number
8173
+ ) => void;
8174
  };
8175
+
8176
+ export declare const Touchable: typeof TouchableImpl;
8177
+
8178
+ export declare type Touchable = typeof Touchable;
8179
+
8180
+ declare const Touchable_2:
8181
+ | typeof TouchableNativeFeedback
8182
+ | typeof TouchableOpacity;
8183
+
8184
+ declare const Touchable_3: (
8185
+ props: Omit<
8186
+ TouchableOpacityProps,
8187
+ keyof {
8188
+ ref?: React.Ref<React.ComponentRef<typeof Animated.View>>;
8189
+ }
8190
+ > & {
8191
+ ref?: React.Ref<React.ComponentRef<typeof Animated.View>>;
8192
+ }
8193
+ ) => React.ReactNode;
8194
+
8195
+ export declare const TouchableHighlight: typeof TouchableHighlight_2;
8196
+
8197
+ export declare type TouchableHighlight = typeof TouchableHighlight;
8198
+
8199
+ declare const TouchableHighlight_2: (
8200
+ props: Omit<
8201
+ Readonly<
8202
+ Pick<
8203
+ TouchableHighlightProps,
8204
+ Exclude<
8205
+ keyof TouchableHighlightProps,
8206
+ keyof {
8207
+ readonly hostRef: unknown;
8208
+ }
8209
+ >
8210
+ >
8211
+ >,
8212
+ keyof {
8213
+ ref?: React.Ref<React.ComponentRef<typeof View>>;
8214
+ }
8215
+ > & {
8216
+ ref?: React.Ref<React.ComponentRef<typeof View>>;
8217
+ }
8218
+ ) => React.ReactNode;
8219
+
8220
+ declare type TouchableHighlightBaseProps = Readonly<{
 
 
8221
  activeOpacity?: number | undefined;
8222
+
 
 
8223
  underlayColor?: ColorValue | undefined;
8224
+
8225
+ style?: ViewStyleProp | undefined;
8226
+
8227
+ onShowUnderlay?: (() => void) | undefined;
8228
+
8229
+ onHideUnderlay?: (() => void) | undefined;
8230
+ testOnly_pressed?: boolean | undefined;
8231
+ hostRef: React.Ref<React.ComponentRef<typeof View>>;
8232
+ }>;
8233
+
8234
+ export declare type TouchableHighlightProps = Readonly<
8235
+ Omit<
8236
+ TouchableWithoutFeedbackProps,
8237
+ keyof (AndroidProps | IOSProps | TouchableHighlightBaseProps | {})
8238
+ > &
8239
+ Omit<AndroidProps, keyof (IOSProps | TouchableHighlightBaseProps | {})> &
8240
+ Omit<IOSProps, keyof (TouchableHighlightBaseProps | {})> &
8241
+ Omit<TouchableHighlightBaseProps, keyof {}> & {}
8242
+ >;
8243
+
8244
+ declare const TouchableImpl: {
8245
+ Mixin: typeof TouchableMixinImpl;
8246
+
8247
+ renderDebugView: ($$PARAM_0$$: {
8248
+ color: ColorValue;
8249
+ hitSlop?: EdgeInsetsProp;
8250
+ }) => null | React.ReactNode;
8251
+ };
8252
+
8253
+ declare const TouchableMixinImpl: {
8254
+ componentDidMount: () => void;
8255
+
8256
+ componentWillUnmount: () => void;
8257
+
8258
+ touchableGetInitialState: () => {
8259
+ touchable: {
8260
+ touchState: State_4 | undefined;
8261
+ responderID: GestureResponderEvent['currentTarget'] | undefined;
8262
+ };
8263
+ };
8264
+
8265
+ touchableHandleResponderTerminationRequest: () => any;
8266
+
8267
+ touchableHandleStartShouldSetResponder: () => any;
8268
+
8269
+ touchableLongPressCancelsPress: () => boolean;
8270
+
8271
+ touchableHandleResponderGrant: (e: GestureResponderEvent) => void;
8272
+
8273
+ touchableHandleResponderRelease: (e: GestureResponderEvent) => void;
8274
+
8275
+ touchableHandleResponderTerminate: (e: GestureResponderEvent) => void;
8276
+
8277
+ touchableHandleResponderMove: (e: GestureResponderEvent) => void;
8278
+
8279
+ touchableHandleFocus: (e: Event) => void;
8280
+
8281
+ touchableHandleBlur: (e: Event) => void;
 
 
8282
+ withoutDefaultFocusAndBlur: {};
8283
+ };
8284
+
8285
+ export declare class TouchableNativeFeedback extends React.Component<
8286
+ TouchableNativeFeedbackProps,
8287
+ State
8288
+ > {
8289
+ static SelectableBackground: (
8290
+ rippleRadius?: null | undefined | number
8291
+ ) => Readonly<{
8292
+ attribute: 'selectableItemBackground';
8293
+ type: 'ThemeAttrAndroid';
8294
+ rippleRadius: number | undefined;
8295
+ }>;
8296
+ static SelectableBackgroundBorderless: (
8297
+ rippleRadius?: null | undefined | number
8298
+ ) => Readonly<{
8299
+ attribute: 'selectableItemBackgroundBorderless';
8300
+ type: 'ThemeAttrAndroid';
8301
+ rippleRadius: number | undefined;
8302
+ }>;
8303
+ static Ripple: (
8304
+ color: string,
8305
  borderless: boolean,
8306
+ rippleRadius?: null | undefined | number
8307
+ ) => Readonly<{
8308
+ borderless: boolean;
8309
+ color: number | undefined;
8310
+ rippleRadius: number | undefined;
8311
+ type: 'RippleAndroid';
8312
+ }>;
8313
+ static canUseNativeForeground: () => boolean;
8314
+ state: State;
8315
+ render(): React.ReactNode;
8316
+ componentDidUpdate(
8317
+ prevProps: TouchableNativeFeedbackProps,
8318
+ prevState: State
8319
+ ): void;
8320
+ componentDidMount(): unknown;
8321
+ componentWillUnmount(): void;
8322
  }
8323
+
 
 
8324
+ export declare type TouchableNativeFeedbackProps = Readonly<
8325
+ Omit<
 
8326
+ TouchableWithoutFeedbackProps,
8327
+ keyof (
8328
+ | TVProps
8329
+ | {
8330
+ background?:
8331
+ | (
8332
+ | Readonly<{
8333
+ type: 'ThemeAttrAndroid';
8334
+ attribute:
8335
+ | 'selectableItemBackground'
8336
+ | 'selectableItemBackgroundBorderless';
8337
+ rippleRadius: number | undefined;
8338
+ }>
8339
+ | Readonly<{
8340
+ type: 'RippleAndroid';
8341
+ color: number | undefined;
8342
+ borderless: boolean;
8343
+ rippleRadius: number | undefined;
8344
+ }>
8345
+ )
8346
+ | undefined;
8347
+
8348
+ useForeground?: boolean | undefined;
8349
+ }
8350
+ )
8351
+ > &
8352
+ Omit<
8353
+ TVProps,
8354
+ keyof {
8355
+ background?:
8356
+ | (
8357
+ | Readonly<{
8358
+ type: 'ThemeAttrAndroid';
8359
+ attribute:
8360
+ | 'selectableItemBackground'
8361
+ | 'selectableItemBackgroundBorderless';
8362
+ rippleRadius: number | undefined;
8363
+ }>
8364
+ | Readonly<{
8365
+ type: 'RippleAndroid';
8366
+ color: number | undefined;
8367
+ borderless: boolean;
8368
+ rippleRadius: number | undefined;
8369
+ }>
8370
+ )
8371
+ | undefined;
8372
+
8373
+ useForeground?: boolean | undefined;
8374
+ }
8375
+ > & {
8376
+ background?:
8377
+ | (
8378
+ | Readonly<{
8379
+ type: 'ThemeAttrAndroid';
8380
+ attribute:
8381
+ | 'selectableItemBackground'
8382
+ | 'selectableItemBackgroundBorderless';
8383
+ rippleRadius: number | undefined;
8384
+ }>
8385
+ | Readonly<{
8386
+ type: 'RippleAndroid';
8387
+ color: number | undefined;
8388
+ borderless: boolean;
8389
+ rippleRadius: number | undefined;
8390
+ }>
8391
+ )
8392
+ | undefined;
8393
+
8394
+ useForeground?: boolean | undefined;
8395
+ }
8396
  >;
8397
+
8398
+ export declare const TouchableOpacity: typeof Touchable_3;
8399
+
8400
+ export declare type TouchableOpacity = typeof TouchableOpacity;
8401
+
8402
+ declare type TouchableOpacityBaseProps = Readonly<{
 
 
8403
  activeOpacity?: number | undefined;
 
 
 
 
8404
+ style?: ViewStyleProp | undefined;
8405
+ hostRef?: React.Ref<React.ComponentRef<typeof Animated.View>> | undefined;
8406
+ }>;
8407
+
8408
+ export declare type TouchableOpacityProps = Readonly<
8409
+ Omit<
8410
+ TouchableWithoutFeedbackProps,
8411
+ keyof (TVProps_2 | TouchableOpacityBaseProps | {})
8412
+ > &
8413
+ Omit<TVProps_2, keyof (TouchableOpacityBaseProps | {})> &
8414
+ Omit<TouchableOpacityBaseProps, keyof {}> & {}
8415
+ >;
8416
+
8417
+ export declare function TouchableWithoutFeedback(
8418
+ props: TouchableWithoutFeedbackProps
8419
+ ): React.ReactNode;
8420
+
8421
+ export declare type TouchableWithoutFeedbackProps = Readonly<
8422
+ {
8423
+ children?: React.ReactNode | undefined;
8424
+
8425
+ delayLongPress?: number | undefined;
8426
+
8427
+ delayPressIn?: number | undefined;
8428
+
8429
+ delayPressOut?: number | undefined;
8430
+
8431
+ disabled?: boolean | undefined;
8432
+
8433
+ focusable?: boolean | undefined;
8434
+
8435
+ hitSlop?: EdgeInsetsOrSizeProp | undefined;
8436
+
8437
+ id?: string;
8438
+ importantForAccessibility?:
8439
+ | ('auto' | 'yes' | 'no' | 'no-hide-descendants')
8440
+ | undefined;
8441
+ nativeID?: string | undefined;
8442
+ onAccessibilityAction?:
8443
+ | ((event: AccessibilityActionEvent) => unknown)
8444
+ | undefined;
8445
+
8446
+ onBlur?: ((event: BlurEvent) => unknown) | undefined;
8447
+
8448
+ onFocus?: ((event: FocusEvent_2) => unknown) | undefined;
8449
+
8450
+ onLayout?: ((event: LayoutChangeEvent) => unknown) | undefined;
8451
+ onLongPress?: ((event: GestureResponderEvent) => unknown) | undefined;
8452
+
8453
+ onPress?: ((event: GestureResponderEvent) => unknown) | undefined;
8454
+ onPressIn?: ((event: GestureResponderEvent) => unknown) | undefined;
8455
+ onPressOut?: ((event: GestureResponderEvent) => unknown) | undefined;
8456
+
8457
+ pressRetentionOffset?: EdgeInsetsOrSizeProp | undefined;
8458
+ rejectResponderTermination?: boolean | undefined;
8459
+
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
8460
+ testID?: string | undefined;
8461
+
8462
+ style?: ViewStyleProp | undefined;
8463
+ } & TouchableWithoutFeedbackPropsAndroid &
8464
+ TouchableWithoutFeedbackPropsIOS &
8465
+ AccessibilityProps
8466
+ >;
8467
+
8468
+ declare type TouchableWithoutFeedbackPropsAndroid = {
8469
  touchSoundDisabled?: boolean | undefined;
8470
+ };
8471
+
8472
+ declare type TouchableWithoutFeedbackPropsIOS = {};
8473
+
8474
+ declare type TouchEventProps = Readonly<{
 
 
 
 
 
 
 
 
 
 
 
8475
+ onTouchCancel?: ((e: GestureResponderEvent) => void) | undefined;
8476
+ onTouchCancelCapture?: ((e: GestureResponderEvent) => void) | undefined;
8477
+ onTouchEnd?: ((e: GestureResponderEvent) => void) | undefined;
8478
+ onTouchEndCapture?: ((e: GestureResponderEvent) => void) | undefined;
8479
+ onTouchMove?: ((e: GestureResponderEvent) => void) | undefined;
8480
+ onTouchMoveCapture?: ((e: GestureResponderEvent) => void) | undefined;
8481
+ onTouchStart?: ((e: GestureResponderEvent) => void) | undefined;
8482
+ onTouchStartCapture?: ((e: GestureResponderEvent) => void) | undefined;
 
 
 
8483
+ }>;
8484
+
 
 
 
 
 
 
 
 
 
8485
+ declare interface TurboModule extends DEPRECATED_RCTExport<void> {}
8486
+
 
 
 
 
 
 
 
8487
  export declare namespace TurboModuleRegistry {
8488
  export {get, getEnforcing};
8489
  }
8490
+
8491
+ declare type TVProps = {
8492
  hasTVPreferredFocus?: boolean | undefined;
8493
+
8494
  nextFocusDown?: number | undefined;
8495
+
8496
  nextFocusForward?: number | undefined;
8497
+
8498
  nextFocusLeft?: number | undefined;
8499
+
8500
  nextFocusRight?: number | undefined;
8501
+
8502
  nextFocusUp?: number | undefined;
8503
+ };
8504
+
8505
+ declare type TVProps_2 = Readonly<{
 
8506
  hasTVPreferredFocus?: boolean | undefined;
8507
+
8508
+ nextFocusDown?: number | undefined;
8509
+
8510
+ nextFocusForward?: number | undefined;
8511
+
8512
+ nextFocusLeft?: number | undefined;
8513
+
8514
+ nextFocusRight?: number | undefined;
8515
+
8516
+ nextFocusUp?: number | undefined;
8517
+ }>;
8518
+
8519
+ export declare type TVViewPropsIOS = Readonly<{
8520
+ isTVSelectable?: boolean;
8521
+
8522
+ hasTVPreferredFocus?: boolean;
8523
+
8524
+ tvParallaxShiftDistanceX?: number;
8525
+
8526
+ tvParallaxShiftDistanceY?: number;
8527
+
8528
+ tvParallaxTiltAngle?: number;
8529
+
8530
+ tvParallaxMagnification?: number;
8531
+ }>;
8532
+
8533
+ export declare const UIManager: typeof UIManager_2;
8534
+
8535
+ export declare type UIManager = typeof UIManager;
8536
+
8537
+ declare const UIManager_2: UIManagerJSInterface;
8538
+
8539
+ declare interface UIManagerJSInterface extends Spec_2 {
8540
+ readonly getViewManagerConfig: (viewManagerName: string) => Object;
8541
+ readonly hasViewManagerConfig: (viewManagerName: string) => boolean;
8542
  }
8543
+
 
8544
+ declare function unforkEvent(
8545
+ event: (null | undefined | AnimatedEvent) | (null | undefined | Function),
 
8546
+ listener: Function
 
8547
+ ): void;
8548
+
 
 
8549
+ declare const unforkEvent_2: typeof AnimatedImplementation_MODULE_EXPORT.unforkEvent;
8550
+
 
8551
+ declare type unforkEvent_2 = typeof unforkEvent_2;
8552
+
 
 
 
 
8553
+ declare function unmountApplicationComponentAtRootTag(rootTag: RootTag): void;
8554
+
 
 
 
 
 
8555
  declare type UnsafeMixed = unknown;
8556
+
8557
+ declare type UnsafeObject = Object;
8558
+
8559
+ declare type UnsafeObject_2 = Object;
8560
+
8561
+ declare type UnsafeObject_3 = Object;
8562
+
8563
+ export declare function unstable_batchedUpdates<T>(
8564
+ fn: ($$PARAM_0$$: T) => void,
8565
+ bookkeeping: T
8566
+ ): void;
8567
+
8568
  export declare function useAnimatedValue(
8569
  initialValue: number,
8570
+ config?: null | undefined | Animated.AnimatedConfig
8571
  ): Animated.Value;
8572
+
8573
+ export declare function useColorScheme(): null | undefined | ColorSchemeName;
8574
+
8575
+ export declare function useWindowDimensions():
8576
+ | DisplayMetrics
8577
+ | DisplayMetricsAndroid;
8578
+
8579
+ export declare const UTFSequence: typeof UTFSequence_2;
8580
+
8581
+ export declare type UTFSequence = typeof UTFSequence;
8582
+
8583
+ declare const UTFSequence_2: {
8584
+ BOM: string;
8585
+ BULLET: string;
8586
+ BULLET_SP: string;
8587
+ MDASH: string;
8588
+ MDASH_SP: string;
8589
+ MIDDOT: string;
8590
+ MIDDOT_KATAKANA: string;
8591
+ MIDDOT_SP: string;
8592
+ NBSP: string;
8593
+ NDASH: string;
8594
+ NDASH_SP: string;
8595
+ NEWLINE: string;
8596
+ PIZZA: string;
8597
+ TRIANGLE_LEFT: string;
8598
+ TRIANGLE_RIGHT: string;
8599
+ };
8600
+
8601
+ declare type Value = {
8602
+ horizontal: boolean;
8603
+ } | null;
8604
+
8605
+ declare type ValueXYListenerCallback = (value: {
8606
+ x: number;
8607
+ y: number;
8608
+ }) => unknown;
8609
+
8610
+ export declare const Vibration: typeof Vibration_2;
8611
+
8612
+ export declare type Vibration = typeof Vibration;
8613
+
8614
+ declare const Vibration_2: {
8615
+ vibrate: (pattern?: number | Array<number>, repeat?: boolean) => void;
8616
+
8617
+ cancel: () => void;
8618
+ };
8619
+
8620
+ export declare const View: typeof View_2;
8621
+
8622
+ export declare type View = typeof View;
8623
+
8624
+ declare const View_2: (
8625
+ props: Omit<
8626
+ ViewProps,
8627
+ keyof {
8628
+ ref?: React.Ref<
8629
+ React.ComponentRef<typeof ViewNativeComponent_MODULE_EXPORT>
8630
+ >;
8631
+ }
8632
+ > & {
8633
+ ref?: React.Ref<
8634
+ React.ComponentRef<typeof ViewNativeComponent_MODULE_EXPORT>
8635
+ >;
8636
+ }
8637
+ ) => React.ReactNode;
8638
+
8639
+ declare type View_3 = typeof View;
8640
+
8641
+ declare type ViewBaseProps = Readonly<{
8642
+ children?: React.ReactNode;
8643
+ style?: ViewStyleProp | undefined;
8644
+
8645
  collapsable?: boolean | undefined;
8646
+
8647
  collapsableChildren?: boolean | undefined;
8648
+
8649
+ id?: string;
8650
+
8651
+ testID?: string | undefined;
8652
+
8653
+ nativeID?: string | undefined;
8654
+
8655
+ needsOffscreenAlphaCompositing?: boolean | undefined;
8656
+
8657
+ hitSlop?: EdgeInsetsOrSizeProp | undefined;
8658
+
8659
+ pointerEvents?: ('auto' | 'box-none' | 'box-only' | 'none') | undefined;
8660
+
8661
+ removeClippedSubviews?: boolean | undefined;
8662
+ }>;
8663
+
8664
+ declare const ViewNativeComponent: HostComponent<ViewProps>;
8665
+
8666
+ declare const ViewNativeComponent_MODULE_EXPORT: typeof ViewNativeComponent;
8667
+
8668
+ declare type ViewNativeComponent_MODULE_EXPORT =
8669
+ typeof ViewNativeComponent_MODULE_EXPORT;
8670
+
8671
+ export declare type ViewProps = Readonly<
8672
+ Omit<
8673
+ DirectEventProps,
8674
+ keyof (
8675
+ | GestureResponderHandlers
8676
+ | MouseEventProps
8677
+ | PointerEventProps
8678
+ | FocusEventProps
8679
+ | TouchEventProps
8680
+ | ViewPropsAndroid
8681
+ | ViewPropsIOS
8682
+ | AccessibilityProps
8683
+ | ViewBaseProps
8684
+ | {}
8685
+ )
8686
+ > &
8687
+ Omit<
8688
+ GestureResponderHandlers,
8689
+ keyof (
8690
+ | MouseEventProps
8691
+ | PointerEventProps
8692
+ | FocusEventProps
8693
+ | TouchEventProps
8694
+ | ViewPropsAndroid
8695
+ | ViewPropsIOS
8696
+ | AccessibilityProps
8697
+ | ViewBaseProps
8698
+ | {}
8699
+ )
8700
+ > &
8701
+ Omit<
8702
+ MouseEventProps,
8703
+ keyof (
8704
+ | PointerEventProps
8705
+ | FocusEventProps
8706
+ | TouchEventProps
8707
+ | ViewPropsAndroid
8708
+ | ViewPropsIOS
8709
+ | AccessibilityProps
8710
+ | ViewBaseProps
8711
+ | {}
8712
+ )
8713
+ > &
8714
+ Omit<
8715
+ PointerEventProps,
8716
+ keyof (
8717
+ | FocusEventProps
8718
+ | TouchEventProps
8719
+ | ViewPropsAndroid
8720
+ | ViewPropsIOS
8721
+ | AccessibilityProps
8722
+ | ViewBaseProps
8723
+ | {}
8724
+ )
8725
+ > &
8726
+ Omit<
8727
+ FocusEventProps,
8728
+ keyof (
8729
+ | TouchEventProps
8730
+ | ViewPropsAndroid
8731
+ | ViewPropsIOS
8732
+ | AccessibilityProps
8733
+ | ViewBaseProps
8734
+ | {}
8735
+ )
8736
+ > &
8737
+ Omit<
8738
+ TouchEventProps,
8739
+ keyof (
8740
+ | ViewPropsAndroid
8741
+ | ViewPropsIOS
8742
+ | AccessibilityProps
8743
+ | ViewBaseProps
8744
+ | {}
8745
+ )
8746
+ > &
8747
+ Omit<
8748
+ ViewPropsAndroid,
8749
+ keyof (ViewPropsIOS | AccessibilityProps | ViewBaseProps | {})
8750
+ > &
8751
+ Omit<ViewPropsIOS, keyof (AccessibilityProps | ViewBaseProps | {})> &
8752
+ Omit<AccessibilityProps, keyof (ViewBaseProps | {})> &
8753
+ Omit<ViewBaseProps, keyof {}> & {}
8754
+ >;
8755
+
8756
+ export declare type ViewPropsAndroid = Readonly<{
8757
+ nativeBackgroundAndroid?: AndroidDrawable | undefined;
8758
+ nativeForegroundAndroid?: AndroidDrawable | undefined;
8759
+
8760
  renderToHardwareTextureAndroid?: boolean | undefined;
8761
+
8762
+ hasTVPreferredFocus?: boolean | undefined;
8763
+
8764
+ nextFocusDown?: number | undefined;
8765
+
8766
+ nextFocusForward?: number | undefined;
8767
+
8768
+ nextFocusLeft?: number | undefined;
8769
+
8770
+ nextFocusRight?: number | undefined;
8771
+
8772
+ nextFocusUp?: number | undefined;
8773
+
8774
  focusable?: boolean | undefined;
8775
+
8776
+ tabIndex?: 0 | -1;
8777
+
8778
+ onClick?: ((event: GestureResponderEvent) => unknown) | undefined;
8779
+ }>;
8780
+
8781
+ export declare type ViewPropsIOS = Readonly<{
8782
  shouldRasterizeIOS?: boolean | undefined;
8783
+ }>;
8784
+
8785
+ export declare type ViewStyle = ____ViewStyle_Internal;
8786
+
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
8787
+ declare type ViewStyleProp = ____ViewStyleProp_Internal;
8788
+
 
 
 
 
 
 
 
8789
+ declare type ViewStyleProp_2 = React.JSX.LibraryManagedAttributes<
 
 
 
 
 
 
8790
+ typeof View,
 
 
 
 
 
 
 
8791
+ React.ComponentProps<typeof View>
 
8792
+ >['style'];
8793
+
8794
+ export declare const VirtualizedList: typeof VirtualizedList_3;
8795
+
8796
+ export declare type VirtualizedList = typeof VirtualizedList;
8797
+
8798
+ declare const VirtualizedList_2: typeof VirtualizedLists.VirtualizedList;
8799
+
8800
+ declare const VirtualizedList_3: VirtualizedListType;
8801
+
8802
+ export {VirtualizedListProps};
8803
+
8804
+ declare type VirtualizedListProps_2 = React.JSX.LibraryManagedAttributes<
8805
+ typeof VirtualizedList_2,
8806
+ React.ComponentProps<typeof VirtualizedList_2>
 
8807
  >;
8808
+
8809
+ declare type VirtualizedListType = typeof VirtualizedLists.VirtualizedList;
8810
+
8811
+ export declare const VirtualizedSectionList: typeof VirtualizedSectionList_2;
8812
+
8813
+ export declare type VirtualizedSectionList = typeof VirtualizedSectionList;
8814
+
8815
+ declare const VirtualizedSectionList_2: VirtualizedSectionListType;
8816
+
8817
+ export {VirtualizedSectionListProps};
8818
+
8819
+ declare type VirtualizedSectionListType =
8820
+ typeof VirtualizedLists.VirtualizedSectionList;
8821
+
8822
+ declare type WebPlatform = {
8823
+ OS: 'web';
8824
+ get constants(): {
8825
+ reactNativeVersion: {
8826
+ major: number;
8827
+ minor: number;
8828
+ patch: number;
8829
+ prerelease: string | undefined;
8830
+ };
8831
+ };
8832
+ get isTV(): boolean;
8833
+ get isTesting(): boolean;
8834
+ get isDisableAnimations(): boolean;
8835
+ select: <T>(spec: PlatformSelectSpec<T>) => T;
8836
+ };
8837
+
8838
+ declare type WindowsPlatform = {
8839
+ OS: 'windows';
8840
+ get Version(): number;
8841
+ get constants(): {
8842
+ isTesting: boolean;
8843
+ isDisableAnimations?: boolean;
8844
+ reactNativeVersion: {
8845
+ major: number;
8846
+ minor: number;
8847
+ patch: number;
8848
+ prerelease: string | undefined;
8849
+ };
8850
+ reactNativeWindowsVersion: {
8851
+ major: number;
8852
+ minor: number;
8853
+ patch: number;
8854
+ };
8855
+ osVersion: number;
8856
+ };
8857
+ get isTesting(): boolean;
8858
+ get isDisableAnimations(): boolean;
8859
+ get isTV(): boolean;
8860
+ select: <T>(spec: PlatformSelectSpec<T>) => T;
8861
+ };
8862
+
8863
+ declare type WithAnimatedValue<T> = T extends Builtin | Nullable
8864
+ ? T
8865
+ : T extends Primitive
8866
+ ?
8867
+ | T
8868
+ | AnimatedNode
8869
+ | AnimatedAddition
8870
+ | AnimatedSubtraction
8871
+ | AnimatedDivision
8872
+ | AnimatedMultiplication
8873
+ | AnimatedModulo
8874
+ | AnimatedDiffClamp
8875
+ | AnimatedValue
8876
+ | AnimatedInterpolation<number | string>
8877
+ | AnimatedInterpolation<number>
8878
+ | AnimatedInterpolation<string>
8879
+ : T extends ReadonlyArray<infer P>
8880
+ ? ReadonlyArray<WithAnimatedValue<P>>
8881
+ : T extends {}
8882
+ ? {readonly [K in keyof T]: WithAnimatedValue<T[K]>}
8883
+ : T;
8884
+
8885
  declare type WithDefault<
8886
  Type extends DefaultTypes,
8887
+ Value extends (null | undefined | Type) | string,
8888
+ > = null | undefined | Type;
8889
+
8890
+ declare const Wrapper: (
8891
+ props: Omit<
8892
+ ScrollViewProps,
8893
+ keyof {
8894
+ ref?: React.Ref<PublicScrollViewInstance>;
8895
+ }
8896
+ > & {
8897
+ ref?: React.Ref<PublicScrollViewInstance>;
8898
+ }
8899
+ ) => React.ReactNode;
8900
+
8901
+ declare function Wrapper_2(
8902
+ $$PARAM_0$$: Omit<ModalRefProps, keyof (ModalProps | {})> &
8903
+ Omit<ModalProps, keyof {}> & {}
8904
+ ): React.ReactNode;
8905
+
8906
  export declare type WrapperComponentProvider = (
8907
+ appParameters: Object
8908
+ ) => React.ComponentType<any>;
8909
+
8910
  export {};